传统的创建任务、驱动任务的方式

1.继承Thread类

　　通过继承Thead类，并重写run方法，在run方法里面编码具体的任务，调用对象的start方法驱动任务。

public class TestThread extends Thread{

    private int count = 5;
　　//创建介绍String形参的构造器，一般参数作为任务的名称，以区分不同的线程
    public TestThread(String name) {
        super(name);
    }
　　//run方法体，就是要执行的任务
    public void run() {
        while (true) {
            System.out.println(this);
            if(--count == 0)
                break;
        }
    }
    //重写toString方法实现可读性更好的线程打印
    public String toString() {
        return getName()+"   count="+count;
    }

    public static void main(String[] args) {
　　　　　//创建5个任务对象，并且调用start方法让线程执行任务；
        for(int i=0;i<5;i++) {
            new TestThread("#Thread "+i).start();
        }
　　　　　//这里往下都是当前线程（即是执行main函数这个线程），而自定义的TestThread任务都是在main线程中开启新的线程来驱动
    }
}
输出：

#Thread 0 count=5
#Thread 3 count=5
#Thread 1 count=5
#Thread 2 count=5
#Thread 1 count=4
#Thread 3 count=4
#Thread 3 count=3
#Thread 0 count=4
#Thread 3 count=2
#Thread 1 count=3

…

#Thread 0 count=1
#Thread 4 count=3
#Thread 4 count=2
#Thread 2 count=2
#Thread 4 count=1
#Thread 2 count=1

　　从log可以看出，这些任务被调动的机会很随机，这取决于线程调度器，而调度器的调度机制又取决于运行的操作系统，即是在同一个平台上，运行多次每次都会出现不一致的结果。

2.实现Runnable接口

　　这种方式与继承Thread类的方式类似，任务类实现Runnable接口的run方法，但是这个任务只是被定义了，并没有产生线程的行为，所以还必须把任务类作为创建Thread对象的构造器形参，并通过调用Thread实例的start方法，使任务附着到线程中。

public class LiftOff implements Runnable{

    private int count=4;

    private static int taskId = 0;

    private int id = taskId++;

    private String getStatus() {
        return "task"+id+"("+count+")";
    }
　　//定义任务
    public void run() {
        while (count-->0) {
            System.out.println(getStatus());
        }
    }

    public static void main(String[] args) {
        for(int i=0;i<3;i++) {
　　　　　　　　//将任务对象实例通过构造器传递给Thread实例，使任务附着到线程上得到执行
            new Thread(new LiftOff()).start();
        }
    }
}
输出：

task1(3)
task2(3)
task0(3)
task2(2)
task1(2)
task2(1)
task0(2)
task2(0)
task1(1)
task0(1)
task1(0)
task0(0)

　　同继承Thread类执行线程一样，任务都是被“随机”执行。不过，这种方式下，任务与线程明确分开在不同的对象，架构比前一种要清晰。

使用Executor

　　从JavaSE5起，提供了执行器（Executor）来简化并发编程。使用Executor，我们不需要收到创建Thread实例，将任务交给Excutor，至于把任务附着到线程上执行，又或者管理线程的生命周期，都不需要我们处理。

public class CacheThreadPoolTest {

    public static void main(String[] args) {
　　　　//通过静态方法创建newCacheThreadPool的Exector，可以创建FixedThreadPool、SingleThreadExecutor等类型的Executor
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i=0;i<5;i++) {
　　　　　　　//将任务加到Executor上
            exec.execute(new LiftOff());
        }
　　　　　//开始顺序关闭Executor开启的线程，之后不能再添加任务到Executor，任务执行完后相应的线程将被关闭
        exec.shutdown();
    }
}

　　Executor很好地分离的任务及驱动任务的线程角色，客户端只需要专注于任务定义，而线程创建管理则交给Executor来负责。下面看看几种不同的Executor的特点：

CachedThreadPool：Executor首选的线程池，通常会创建与所需数量相同的线程，在回收旧线程时停止创建新线程；
FixedThreadPool：一次性预先创建固定数量的线程，可以节省后期线程创建的开销，并且防止滥用线程；
SingleThreadExecutor：类似线程数量为1的FixedThreadPool，适用于所以任务都要在同一个线程中执行的情景（执行次序为任务被提交的先后顺序），还可以用于执行短任务；

public class LiftOff implements Runnable{

    private int count=4;

    private static int taskId = 0;

    private int id = taskId++;

    private String getStatus() {
        return "task"+id+"("+count+")";
    }

    public void run() {
        try {
            while (count-->0) {
                System.out.println(getStatus());
                Thread.sleep(2000);
            }
        }catch (Exception e) {
            e.printStackTrace(System.out);
        }
    }

}

public class SingleThreadExecutorTest {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for(int i=0;i<3;i++) {
            executor.execute(new LiftOff());
        }
　　　　//这里一定要关闭线程，否则主线程将一直阻塞
　　　　　executor.shutdown();
    }
}
输出：

task0(3)
task0(2)
task0(1)
task0(0)
task1(3)
task1(2)
task1(1)
task1(0)
task2(3)
task2(2)
task2(1)
task2(0)

从任务中产生返回值

　　无论是实现Runnable接口还是继承Thread类，都只是单独执行任务，没能返回值。要想从任务中产生返回值，需要使用Callable接口，其中重写call方法并得到参数化的Future类型的返回值。实现Callable接口的任务需要Executor使用submit来提交。

//定义任务，实现Callable，返回值类型为String
public class TaskWithResult implements Callable<String>{

    private static int taskId = 0;

    private int id = taskId++;

    public String toString() {
        return "#task"+id;
    }

    public String call() throws Exception {
        return this.toString();
    }
}

public class CallableTest {

    public static void main(String[] args) throws Exception{
        ExecutorService executor = Executors.newSingleThreadExecutor();
        List<Future<String>> futureList = new ArrayList<Future<String>>();
        for(int i=0;i<3;i++) {
　　　　　　　//通过executor的submit来提交，submit返回参数化的Future类型
            futureList.add(executor.submit(new TaskWithResult()));
        }
        executor.shutdown();
        for(Future<String> future: futureList) {
　　　　　　　//Future的get可以得到任务的真正返回值
            System.out.println(future.get());
        }
    }
}
输出：

#task0
#task1
#task2

　　需要注意的是，从Future中得到返回值时使用了get，但是get会引起阻塞直到任务完成并返回，为了避免阻塞，可以用isDone方法来查询Future是否完成。