Java并发框架Executor

Executor：可管理Thread对象，它在客户端和任务执行之间提供了一个间接层。它允许我们管理异步任务的执行，而无需显示的管理线程的生命周期。

创建线程池:
Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

1、Executors.newCachedThreadPool()：

CachedThreadPool：在线程的执行过程中通常会创建与所需数量相同的线程，然后在他回收旧线程时停止创建新线程。因此，它是合理的Executors首选。

public class TestExecutors {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        cachedThreadPool.execute(new Thread( new TestThread("t1")));
        cachedThreadPool.execute(new Thread( new TestThread("t2")));
        cachedThreadPool.shutdown();
    }

}

class TestThread implements Runnable{
    String name;

    public TestThread(String name){
        this.name= name;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<5;i++){

            System.out.println(name+":"+i);
        }
    }
}

输出结果为：
t1:0
t1:1
t1:2
t1:3
t1:4
t2:0
t2:1
t2:2
t2:3
t2:4

2、Executors.newFixedThreadPool()：
FixedThreadPool()：使用了有限的线程集来执行所提交的事务。可以一次性预先执行代价高昂的线程分配，因而也就可以限制线程的数量了。此时，不需要为每个任务都固定的付出创建线程的开销。在事件驱动的系统中，需要线程的事件处理器，通过直接从池中获取线程，也可以尽快的得到服务。规定数目的线程处理所有任务，一旦有线程处理完了任务就会被用来处理新的任务(如果有的话)。新的线程加入后，如果正在运行的线程达到了上限，则会阻塞，直到有了空闲的线程来运行

public class TestExecutors {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        ExecutorService exec = Executors.newFixedThreadPool(2);      
        for(int i = 0; i < 4; i++) {   
            exec.execute(new Thread( new TestThread("t"+i)));   
        }   
        exec.shutdown(); 
    }

}

class TestThread implements Runnable{
    String name;

    public TestThread(String name){
        this.name= name;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<2;i++){

            System.out.println(name+":"+i);
        }
    }

}

输出结果为：
t0:0
t0:1
t0:2
t0:3
t1:0
t2:0
t1:1
t2:1
t1:2
t2:2
t1:3
t2:3
t3:0
t4:0
t3:1
t4:1
t3:2
t4:2
t3:3
t4:3
同时只有两个线程在执行

3、Executors.newSingleThreadPool()：
SingleThreadPool：就像是线程数量为1的FixedThreadPool。向SingleThreadExecutor提交多个任务时，这些任务将排队，每个任务都会在下一个任务开始之前运行结束，所有的任务都将使用相同的线程。采用SingleThreadExecutor来处理大量的线程时，可以确保时刻在任何线程中都只有唯一的任务在运行。在这种方式中，不需要再共享资源上处理同步。

public class TestExecutors {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        ExecutorService exec = Executors.newSingleThreadExecutor();      
        for(int i = 0; i < 3; i++) {   
            exec.execute(new Thread( new TestThread("t"+i)));   
        }   
        exec.shutdown(); 
    }

}

class TestThread implements Runnable{
    String name;

    public TestThread(String name){
        this.name= name;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<4;i++){

            System.out.println(name+":"+i);
        }
    }

}


输出结果为：
t0:0
t0:1
t0:2
t0:3
t1:0
t1:1
t1:2
t1:3
t2:0
t2:1
t2:2
t2:3

都是在上一个线程执行完了在执行下一个线程