java多线程之线程池

　与数据库连接池类似，线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象或Callable对象传给线程池，线程池就会启动一个线程来执行它们的run()或call()方法，当执行完毕后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

• Executors工厂类：该工厂类包含多个静态工厂方法来创建线程池。 
  ① newCachedThreadPool()：创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中。 
  ② newFixedThreadPool(int nThreads)：创建一个可重用的、具有固定线程数的线程池 
  ③ newScheduledThreadPool(int corePoolSize)：创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。 
  ④ newWorkStealingPool(int parallelism)：创建持有足够的线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争。
• ExecutorService类：代表尽执行线程的线程池，即只要线程池中有空闲线程，就立即执行线程任务
• ScheduledExecutorService类：代表可在指定延迟后或周期性地执行线程任务的线程池。

使用线程池来执行线程任务的步骤如下：

1. 调用Executors类的静态工厂方法创建一个ExecutorService对象，该对象代表一个线程池
2. 创建Runnable实现类或Callable实现类的实例，作为线程执行任务
3. 调用ExecutorService对象的submit()方法来提交Runnable实例或Callable实例
4. 当不想提交任何任务时，调用ExecutorService对象的shutdown()方法来关闭线程

例子:

package com.ming.thread.six.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中。
 * @author ming
 *
 */
public class CachedThreadPoolTest {

    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(index);
                }
            });
        }
    }
}

package com.ming.thread.six.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 * 创建一个可重用的、具有固定线程数的线程池 
 * @author ming
 *
 */
public class FixedThreadPoolTest {

    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

package com.ming.thread.six.threadpool;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 线程迟中定时执行/创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。 
 * @author ming
 *
 */
public class ScheduledThreadPoolTest {

    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("delay 3 seconds");
            }
        }, 1, 3, TimeUnit.SECONDS);//表示延迟1秒后每3秒执行一次。
    }

}

package com.ming.thread.six.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 创建持有足够的线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争。
 * @author ming
 *
 */
public class SingleThreadExecutorTest {

    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}