Java实现线程的几种方式

1、继承java.lang.Thread,重写run方法

实现线程的第一种方式：
编写一个类直接继承java.lang.Thread,重写run方法。

怎么创建线程对象？new就行了

怎么启动线程呢？调用线程对象的start()方法就行

public class ThreadTest01 {
    
    
    public static void main(String[] args) {
    
    
        //这里是一个main方法，这里的代码属于主线程，在主栈中运行。
        //新建一个分支线程对象
        MyThead myThead = new MyThead();
        //启动线程

        //myThead.run();//不会启动线程，不会分配新的分支栈。（这种方式就是单线程）

        //start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码的任务完成之后，瞬间就结束了。
        //这段代码的任务只是为了开辟一个新的栈空间，只要新的栈空间开辟出来，start()方法就结束了。线程就启动成功了。
        //启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）
        //run方法在分支栈的栈底部，main方法在主栈的底部。run和main是平级的。
        myThead.start();//这行代码是瞬间结束的
        //这里的代码还是运行在主线程中
        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("主线程-->" + i);
        }
    }
}
class MyThead extends Thread{
    
    
    @Override
    public void run() {
    
       //必须写
        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("分支线程-->" + i);
        }
    }
}

运行结果：

未注释run()方法的运行结果，此时不是并发：

由上述运行结果发现，有以下特点：有先有后、又多有少。

2、实现java.lang.Runnable接口，实现run方法

实现线程的第二种方式：
编写一个类，实现java.lang.Runnable,重写run方法。

这种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其他的类，更灵活。

public class ThreadTest02 {
    
    
    public static void main(String[] args) {
    
    
        //创建一个可运行的对象
        MyRunnable myRunnable = new MyRunnable();
        //将可运行的对象封装成一个线程对象
        Thread t = new Thread(myRunnable);
        //启动线程
        t.start();

        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("主线程-->" + i);
        }
    }
}

//这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable{
    
    
    @Override
    public void run() {
    
    
        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("分支线程-->" + i);
        }
    }
}

3、采用匿名内部类的方式

public class ThreadTest03 {
    
    
    public static void main(String[] args) {
    
    

        //创建线程对象，采用匿名内部类的方式。
        //这是通过一个没有名字的类，new出来的对象。
        Thread t = new Thread(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                for (int i = 0; i < 1000; i++) {
    
    
                    System.out.println("t线程-->" + i);
                }
            }
        });

        //启动线程
        t.start();

        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("主线程-->" + i);
        }
    }
}

4、实现Callable接口（JDK8新特性）

该方法效率较低，因为在获取线程的执行结果的时候，当前线程受阻塞。但是可以拿到线程的返回结果

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadTest12 {
    
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
        //第一步：创建一个“未来任务类”接口
        FutureTask task = new FutureTask(new Callable() {
    
    
            @Override
            public Object call() throws Exception {
    
    //call方法就相当于run方法。只不过这个有返回值
                //线程执行一个任务，执行之后可能会有一个执行结果
                //模拟执行
                System.out.println("call method begin!");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;

                return a + b;//自动装箱（300结果变成Integer）
            }
        });

        //创建线程对象
        Thread t = new Thread(task);

        //启动线程
        t.start();

        //这里是main方法，这是在主线程中
        //在主线程中，怎么获取t线程的返回结果？
        //get发方法的执行会导致“当前线程阻塞”
        Object o = task.get();
        System.out.println("线程执行结果：" + o);

        //main方法这里的程序想执行必须等待get()方法的结束
        //而get()方法是为了拿另一个线程的执行结果
        //另一个线程执行是需要时间的
        System.out.println("hello world!");
    }
}

运行结果：