java线程池的创建使用

　　利用java的多线程编程可以大大的提高系统的并发运行效率，线程越多并发执行的任务就越多，但是并不意味着效率会一直提高，相反会得到适得其反的效果。

　　java中的多线程编程一共有三种方法：

　　　　继承Thread类

　　　　继承Runnable接口

　　　　使用线程池Executor

　　下面简单的介绍一些Executor的使用

　一、话不多说先上代码：

　　创建一个线程数为3的线程池，模拟十个任务让线程池调度线程去完成。

 package executorExample;

 import java.util.concurrent.ExecutorService;

 import java.util.concurrent.Executors;

 public class Threads{

     private static final int nThreads = 3;

     private int i;

     public void Thread(){

         //实现ExecutorService接口创建 线程数为三个的线程池

         ExecutorService executorService = Executors.newFixedThreadPool(nThreads);

         for (i = 0; i < 10; i++) {

             //在匿名内部类中变量index还在必须把index声明成final类型

             final int index = i;

             executorService.execute(new Runnable() {

                 @Override

                 public void run() {

                     // TODO Auto-generated method stub

                     String threadName = Thread.currentThread().getName();//获取当前线程的名字

                     System.out.println(threadName+"正在执行任务:"+index);

                 }

             });

         }

     }

     public static void main(String[] args){

         Threads thread = new Threads();

         thread.Thread();

     }

 }

　　接下来解释一下这段代码。在这段代码当中用到的关键词有ExcutorService,Executors,newFixedThreadPool和execute方法，还有一个最重要的Executor，现在来解释一下他们之间的关系

1、Executors

　　首先我们先看一下Executors的源码

 public static ExecutorService newFixedThreadPool(int nThreads) {

         return new ThreadPoolExecutor(nThreads, nThreads,

                                       0L, TimeUnit.MILLISECONDS,

                                       new LinkedBlockingQueue<Runnable>());

     ｝

 public static ExecutorService newWorkStealingPool(int parallelism) {

         return new ForkJoinPool

             (parallelism,

              ForkJoinPool.defaultForkJoinWorkerThreadFactory,

              null, true);

     }

 public static ExecutorService newWorkStealingPool() {

         return new ForkJoinPool

             (Runtime.getRuntime().availableProcessors(),

              ForkJoinPool.defaultForkJoinWorkerThreadFactory,

              null, true);

     }

 public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {

         return new ThreadPoolExecutor(nThreads, nThreads,

                                       0L, TimeUnit.MILLISECONDS,

                                       new LinkedBlockingQueue<Runnable>(),

                                       threadFactory);

     }

 public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {

 　　　　return new FinalizableDelegatedExecutorService

 　　　　　　(new ThreadPoolExecutor(1, 1,

 　　　　　　　　　　　　　　　　　　　　0L, TimeUnit.MILLISECONDS,

 　　　　　　　　　　　　　　　　　　　　new LinkedBlockingQueue<Runnable>(),

 　　　　　　　　　　　　　　　　　　　　threadFactory));

 }

 public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {

         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                       60L, TimeUnit.SECONDS,

                                       new SynchronousQueue<Runnable>(),

                                       threadFactory);

     }

　　里面有四种都是ExecutorService类型的线程池，也就是说，我们在创建线程池的时候可以有四种选择，newCachedThreadPool，newFixedThreadPool，newSingleThreadExecutor，newWorkStealingPool。其中最常用的就是newCatchedThreadPool和newFixedThreadPool,可以看到每个线程池的参数队列是不同的，LinkedBlockingQueue<Runnable>()属于无边界队列，

　　(1)newFixedThreadPool

　　　　是一个固定线程数的线程池，当线程池里线程满了之后，下载任务就会被阻塞到等待下载队列里面等待下载。而LinkedBlockingQueue<Runnable>()无限扩容的FIFO规则的队列，我们在编程的时候一般用它比较多。

　　(2)newCatchedThreadPool

　　　　是一个可缓存线程池，如果线程池里的线程数超过了处理需要，则线程池可以灵活的回收空闲的线程，

　　别的线程池就先不介绍了

2、ExecutorService

 public interface ExecutorService extends Executor {

　　在接口ExecutorService的源码中我们可以看到继承了Executor类，并且在ExecutorService方法中实现了

void shutdown();

invokeAll();

submit();

　　等等的方法。

3、Executor

 public interface Executor {

     void execute(Runnable command);

 }

　　在接口Executor中只有一个execute()方法,这是用来将任务提交给线程的。

到这里就明白了他们之间的关系，这样可以帮助我们更好的利用线程池去提高我们的代码效率。

写的不是很完善，如果有大神，希望多多指教，写这个东西也是为了自己能够更熟练的使用线程池。

秒客网