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

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

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对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。