创建线程的三种方式

有三种创建方式：

1. 继承Thread类来创建线程
2. 实现Runnable接口来创建线程
3. 使用Callable和Future创建线程

方法一：定义Thead类的子类并重写里面的run方法，当使用该类启动线程时，直接调用里面的start即可

public class Demo1 extends Thread{
//创建线程的第一种方式
	public void run() {
		System.out.println("第一种创建方式");
	}
	public static void main(String[] args) {
		Demo1 d = new Demo1();
		d.start();
	}

}

输出：

方法二：定义一个Runnable接口的实现类，同样要重写里面的run方法，启动线程调用时一样要调用里面的run方法

public class Demo2 implements Runnable{

	@Override
	public void run() {
		System.out.println("第二种创建方式");
	}
	public static void main(String[] args) {
		Demo2 d2 = new Demo2();
		new Thread(d2, "线程1").start();;
	}
}

输出：

第三种方法：该方法之前（重点介绍）

• Callable与Runnable接口类似，但是有返回值，只有一个方法call
• Future保存异步计算的结果
• FutureTask包装器是一种非常便利的机制，可将Callable转化为Future和Runnable，它同时实现两者的接口

package thread_test;

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

public class Demo3 {
	public static void main(String[] args) {
		// 使用Lambda表达式创建Callable接口的实现类，并实现call（）方法，再创建Callable的实现类的实例
		Callable ca = () -> {
			int sum = 0; // 0~99的总和
			for (int i = 0; i < 100; i++) {
				System.out.println(Thread.currentThread().getName() + " " + i);
				sum += i;
			}
			return sum;
		};
		// 使用FutureTask来包装Callable对象ca
		FutureTask task = new FutureTask<>((Callable) ca);
 
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
			if (i == 20) {
				// 使用FutureTask对象作为Thread对象的target创建并启动新线程
				new Thread(task, "新线程").start();
			}
		}
		// 调用FutureTask对象的get（）方法来获得子线程执行结束后的返回值
		try {
			int r = task.get();
			System.out.println("子线程的返回值：" + r);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

三种方法的比较：

方法一：

优点：编写简单，如需访问当前线程，无须使用Thread.currentThread（）方法，直接使用this即可获得当前线程。

缺点：线程已经继承Thread类，所以不能再继承其他父类。

方法二：

优点：可以继承其他类。多个线程可以共享同一个target。

缺点：run()方法没有返回值，而且不能抛出异常。

方法三:

优点：call（）方法可以有返回值，可以声明抛出异常。

缺点：使用复杂。