JAVA并发编程学习笔记------线程的三种创建方式

Posted 2020-09-02 hunter_Cecil

创建线程一般有如下几个方式：

1. 通过继承Thread类来创建一个线程：

/**
 * 步骤1：定义一个继承Thread类的子类
 * 步骤2：构造子类的一个对象
 * 步骤3：启动线程：
 * */
public class ThreadTest{
	public static void main(String[] args) {
		//构造子类对象
		SubThread subThread = new SubThread();
		//启动线程
		subThread.start();
	}
}
//定义继承Thread的子类
class SubThread extends Thread{
	public void run(){
		System.out.println("Thread test.......");
	}
}

2. 通过实现Runnable接口来创建一个线程（静态代理模式）

/**
 * 静态代理模式的步骤
 * 步骤一： 创建真实角色
 * 步骤二： 创建代理角色，持有真实角色的引用
 * 步骤三： 两者实现相同的接口
 **/
public class RunnableTest {
	public static void main(String[] args) {
		//创建一个类对象
		Runnable subRunnable = new SubRunnable();
		//由Runnable创建一个Thread对象
		Thread  subThread = new Thread(subRunnable);
		//启动线程
		subThread.start();
	}
}

//创建实现Runnable接口的类
class SubRunnable implements Runnable{
	@Override
	public void run() {
		System.out.println("Runnable Test......");
	}
}

3、通过实现Callable接口来创建一个线程（可返回值，对外声明异常等）

/*
 * 步骤一：创建Callable接口的实现类，并重写call()方法
 * 步骤二：借助执行调度服务ExecutorService获取Future对象
 * 步骤三： get()方法获取值
 * 步骤四： shutdownNow()方法停止服务
 */
public class CallableTest {
	public static void main(String[] args) {
		//借助执行调度服务ExecutorService获取Future对象
		ExecutorService ser = Executors.newFixedThreadPool(2);
		Race test1 = new Race("LiLei");
		Race test2 = new Race("HanMeimei");
		Future<String> res1 = ser.submit(test1);
		Future<String> res2 = ser.submit(test2);

		try {
			//get()方法获取值
			System.out.println(res1.get());
			System.out.println(res2.get());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		//shutdownNow()方法停止服务
		ser.shutdownNow();
	}
}

//创建Callable接口的实现类
class Race implements Callable<String> {
	private String name;

	public Race(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String call() throws Exception {
		return "Hello "+ name +"......";
	}
}

总结：

1、推荐使用接口，原因如下：

　　1）避免单继承的局限性；

　　2）便于共享资源

2、两种实现接口的方式（Runnable和Callable）的区别：

　　1）Callable的启动方法是call(),Runnable的启动方法是run()

　　2）Callable的任务执行后可返回值，而Runnable的任务无返回值

　　3）Callable的call方法可以抛出异常，Runnable的run方法不可以

　　4）Callable任务可以获取Future对象，这个对象提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。

　　　  通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。