创建线程的几种方式

目录

• • 继承 Thread 类创建线程
  • 实现 Runnable 接口创建线程
  • Thread 匿名内部内创建线程
  • Runnable 匿名内部类创建线程
  • lambda 表达式创建线程
  • 使用 Callable 创建线程（需要 FutureTask 类来辅助）

继承 Thread 类创建线程

class ThreadTest1 extends Thread {
    @Override
    public void run() {
        System.out.println("继承 Thread 接口创建线程");
    }
}

public class TestDemo2 {
    public static void main1(String[] args) {
        ThreadTest1 threadTest1 = new ThreadTest1();
        threadTest1.start();
    }
}

实现 Runnable 接口创建线程

class ThreadTest2 implements Runnable {
    @Override
    public void run() {
        System.out.println("实现 Runnable 接口创建线程");
    }
}

public class TestDemo2 {

    public static void main(String[] args) {
        Runnable threadTest2 = new ThreadTest2();
        Thread thread = new Thread(threadTest2);
        thread.start();
    }
}

Thread 匿名内部内创建线程

    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("Thread 匿名内部类创建线程");
            }
        };
        thread.start();
    }

这种方式创建线程本质还是通过继承 Thread 类来创建线程

Runnable 匿名内部类创建线程

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable 匿名内部类创建线程");
            }
        });
        thread.start();
    }

这种方式创建线程本质还是通过实现 Runnable 接口来创建线程

lambda 表达式创建线程

    public static void main(String[] args) {
        Thread thread = new Thread(()->
                System.out.println("lambda 表达式创建线程"));
        thread.start();
    }

使用 Callable 创建线程（需要 FutureTask 类来辅助）

class MyCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    	// Callable 泛型参数与下面返回值的类型相同
        Callable<Object> callable = new Callable<Integer>() {
            @Override
            public Object call() throws Exception {
                // doSomething
                return object;
            }
        };
        
		// 使用 FutureTask 把 Callable 包裹起来, 传 task 对象给 Thread
		// FutureTask 起到的作用就是 "未来能获取到一个结果"
		// 也就是 Callable 重写方法中执行的结果
        FutureTask<Integer> task = new FutureTask<>(callable);
        Thread thread = new Thread(task);
        thread.start();
        
        // 通过 FutureTask 的 get 方法获取到结果
        // 如果线程阻塞, 对应的线程没有执行完, get 就等待阻塞
        Integer res = task.get();
    }
}