Java高级应用---线程的三种创建方式

线程和进程应该都听说过，Thread，Process，这里就不介绍概念了，基本的Java线程模型有Thread类，Runnable接口，Callable接口和Future接口等，这些线程模型都是面向对象的。

1. 继承Thread类

其中Thread类的run(),方法是线程中最重要的方法，用于执行线程要完成的任务，我们每次创建一个线程都要重写run方法，当然还有start()方法负责启动。

下面继承Thread类

package com.rain.demo;
public class ThreadDemo extends Thread {//继承Thread类
    public void run(){ //重写run方法
        setName("子线程");  //定义子线程的name
        for (int i=0;i<5;i++){
            System.out.println(this.getName()+":"+i);//打印子线程的name和i值
        }
    }
    public static void main(String[] arge){
        ThreadDemo td = new ThreadDemo(); //创建线程对象
        td.start();                 //启动线程
        for(int i=10;i<15;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);//打印主线程的name和i值
        }
    }
}

执行结果：

main:10
main:11
main:12
子线程:0
main:13
子线程:1
main:14
子线程:2
子线程:3
子线程:4

2. 实现Runable接口

Runnable接口用于标识某个Java类可否作为线程类，该接口只有一个抽象方法run，用于执行线程中的任务。一个尅实现Runnable接口后，并不代表该类是个“线程”类，不能直接启动线程，必须通过Thread类的实例来创建并启动线程。

通过Runnable接口创建并启动线程的步骤：

(1)、定义一个雷实现Runnable接口，并实现该接口中的run方法；

(2)、创建一个Thread类的实例，并将Runnable接口的实现类所创建的对象作为参数传入Thread类的构造方法中；

(3)、调用Thread对象的start方法启动该线程。

代码实现：

package com.rain.demo;
//实现Runnable接口
class ThreadTask implements Runnable {
 @Override
 public void run() {//重写run方法
     // TODO Auto-generated method stub
     for(int i=0;i<5;i++){
         //打印当前线程的name和i值
         System.out.println(Thread.currentThread().getName()+":"+i);
     }
 }
}
 //实现类
 public class RunnableDemo{
     public static void main(String[] args) {
         //实例化Thread类，参数为ThreadTask对象
         Thread td = new Thread(new ThreadTask());
         td.start();//启动线程
         for(int i=10;i<=15;i++){
             //打印主线程name和i值
             System.out.println(Thread.currentThread().getName()+":"+i);
         }
     }

 }

结果

main:10
Thread-0:0
main:11
Thread-0:1
main:12
Thread-0:2
Thread-0:3
Thread-0:4
main:13
main:14
main:15

3. 使用Callable和Future接口

Callable接口提供一个call方法作为线程的执行体，call方法比run方法功能更强大，call方法可以有返回值，也可以声明抛出异常，Future接口用来接收Callable接口中call方法的返回值，Future接口提供一个FutureTask实现类，该类同时实现了Future和Runnable两个接口，因此可以作为Thread类的target参数，使用Callable和Future接口的最大优势在于可以在线程执行完任务之后获取执行结果。

使用Callable和Future接口创建并启动线程的步骤：

(1)、创建Callable接口的实现类，并实现call方法，该方法将作为线程的执行体，并具有返回值，然后创建Callable实现类的实例。

(2)实现FutureTask类来包装Callable对象，在FutureTask对象中封装了Callable对象的call方法的返回值

(3)使用FutureTask对象作为Thread对象的target创建并启动新线程

(4)调用FutureTaks对象的get方法来获得子线程执行结束后的返回值

实例代码

package com.rain.demo;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//创建Callable接口实现类
class Task implements Callable<Integer>{
        @Override
        //实现call方法
        public Integer call() throws Exception {
            // TODO Auto-generated method stub
            int i = 0;
            for(i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            //返回call的返回值
            return i;
        }
    }
//主类
public class CallableFutureDemo{
    public static void main(String[] args) {
        //使用Future类包装Callable实现类的实例
        FutureTask<Integer> task = new FutureTask<Integer>(new Task());
        //创建线程，使用futureTask对象的task作为Thread对象的targer，启动线程
        new Thread(task,"子线程").start();
        try {
            System.out.println("子线程返回值："+task.get());
        }catch(InterruptedException e){
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        for(int i=10;i<15;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

结果

子线程:0
子线程:1
子线程:2
子线程:3
子线程:4
子线程返回值：5
main:10
main:11
main:12
main:13
main:14