jdk线程池,使用手记

Executors----------------------------------------------Executors----------------------------------------------Executors--------------

为了更好的控制多线程,JDK提供了一套线程框架Executor,帮助开发人员有效的进行线程控制。它们都在java.util.concurrent包中,是JDK并发包的核心。
其中有一个比较重要的类:Executors,他扮演着线程工厂的角色,咱们经过Executors能够建立特定功能的线程池。
Executors建立线程池方法:
  newFixedThreadPool();该方法返回一个固定数量的线程池,该方法的线程数始终不变,当有一个任务提交时,若线程池中空闲,则当即执行,若没有,
    则会被暂缓在一个任务队列中,等待有空闲的线程去执行。

  newSingleThreadExecutor();建立一个线程的线程池,若空闲则执行,若没有空闲线程则暂缓在任务队列中。
  newCachedThreadPool();返回一个可根据实际状况调整线程个数的线程池,不限制最大线程数量,若用空闲的线程则执行任务,若无任务则不建立线程。
    而且每个空闲线程会在60秒后自动回收。
  newScheduledThreadPool();该方法返回一个SchededExecutorService对象,相似于第一个方法,但该线程池能够指定线程的数量。

//建立出容量为10的线程池

ExecutorService pool = Executors.newFixedThreadPool(10);
//表示建立了容量为1的线程池
ExecutorService pool2 = Executors.newSingleThreadExecutor();
//建立容量没有限制的线程池
ExecutorService pool3 = Executors.newCachedThreadPool();
//建立固定数量的线程池(指定数量) 底层使用带有延迟和周期性的执行任务机制
ScheduledExecutorService pool4 = Executors.newScheduledThreadPool(10);

分析底层实现:
newFixedThreadPool(10);
/**
* @param nThreads:核心线程
* @return
* new ThreadPoolExecutor
* @param nThreads 核心线程(线程池被实例化后,其内部直接初始化了"nThreads"个线程)
* @param nThreads 最大线程数
* @param 0L 当前线程空闲时间为0
* @param TimeUnit.MILLISECONDS 该线程空闲时间单位(秒、小时...)
* @param new LinkedBlockingQueue<Runnable>() (一种无界队列类型)的存储器,若是池子没有空闲的话,新的线程将会被载入到该队列中
*/
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}

newSingleThreadExecutor();
/**
* @return
* new FinalizableDelegatedExecutorService
* ThreadPoolExecutor
* @param 1 默认在池子里建立一个线程
* @param 1 池子默认大小为1
* @param 0L 当前线程空闲时间为0
* @param TimeUnit.MILLISECONDS 该线程空闲时间单位(秒、小时...)
* @param new LinkedBlockingQueue<Runnable>() (一种无界队列类型)的存储器,若是池子没有空闲的话,新的线程将会被载入到该队列中
*/
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
 
newCachedThreadPool();
/**
* @return
* new ThreadPoolExecutor
* @param 0 初始化该线程池的时候默认不建立线程
* @param Integer.MAX_VALUE 默认该池子的大小为 MAX_VALUE (即不限制大小)
* @param 0 初始化该线程池的时候默认不建立线程
* @param TimeUnit.MILLISECONDS 该线程空闲时间单位(秒、小时...)
* @param new SynchronousQueue<Runnable>())阻塞队列,用于存储等待的任务

*/
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}


Executors----------------------------------------------Executors----------------------------------------------Executors--------------
 
同步辅助类----------------------------------------------同步辅助类----------------------------------------------同步辅助类--------------
CountDownLatch  在完成一组正在其余线程中执行的操做以前,它容许一个或多个线程一直等待; 
使用场景:经常使用语监听某些初始化操做,等初始化执行完毕后,通知主线程继续工做。

  构造方法参数指定了计数的次数java

  countDown方法,当前线程调用此方法,则计数减一多线程

  await方法,调用此方法会一直阻塞当前线程,直到计时器的值为0并发

 1 public class CountDownLatchDemo {
 2     final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 3     public static void main(String[] args) throws InterruptedException {
 4         CountDownLatch latch=new CountDownLatch(2);//两个工人的协做
 5         Worker worker1=new Worker("zhang san", 5000, latch);
 6         Worker worker2=new Worker("li si", 8000, latch);
 7         worker1.start();//
 8         worker2.start();//
 9         latch.await();//等待全部工人完成工做
10         System.out.println("all work done at "+sdf.format(new Date()));
11     }
12     
13     
14     static class Worker extends Thread{
15         String workerName; 
16         int workTime;
17         CountDownLatch latch;
18         public Worker(String workerName ,int workTime ,CountDownLatch latch){
19              this.workerName=workerName;
20              this.workTime=workTime;
21              this.latch=latch;
22         }
23         public void run(){
24             System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));
25             doWork();//工做了
26             System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));
27             latch.countDown();//工人完成工做,计数器减一
28 
29         }
30         
31         private void doWork(){
32             try {
33                 Thread.sleep(workTime);
34             } catch (InterruptedException e) {
35                 e.printStackTrace();
36             }
37         }
38     }
39     
40      
41 }

输出:框架

Worker zhang san do work begin at 2011-04-14 11:05:11
Worker li si do work begin at 2011-04-14 11:05:11
Worker zhang san do work complete at 2011-04-14 11:05:16
Worker li si do work complete at 2011-04-14 11:05:19
all work done at 2011-04-14 11:05:19dom

 
CyclicBarrier 它容许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,
  这些线程必须不时地互相等待,此时 CyclicBarrier 颇有用。由于该 barrier 在释放等待线程后能够重用,因此称它为循环 的 barrier。
使用场景:须要全部的子任务都完成时,才执行主任务,这个时候就能够选择使用CyclicBarrier。
method:
await
public int await()
          throws InterruptedException,
                 BrokenBarrierException
在全部参与者都已经在此 barrier 上调用 await方法以前,将一直等待。若是当前线程不是将到达的最后一个线程,出于调度目的,将禁用它,且在发生如下状况之一前,该线程将一直处于休眠状态:
最后一个线程到达;或者
其余某个线程中断当前线程;或者
其余某个线程中断另外一个等待线程;或者
其余某个线程在等待 barrier 时超时;或者
其余某个线程在此 barrier 上调用 reset()。
若是当前线程:
在进入此方法时已经设置了该线程的中断状态;或者
在等待时被中断
则抛出 InterruptedException,而且清除当前线程的已中断状态。若是在线程处于等待状态时 barrier 被 reset(),或者在调用 await 时 barrier 被损坏,抑或任意一个线程正处于等待状态,
则抛出 BrokenBarrierException 异常。 若是任何线程在等待时被 中断,则其余全部等待线程都将抛出 BrokenBarrierException 异常,并将 barrier 置于损坏状态。 若是当前线程是最后一个将要到达的线程,而且构造方法中提供了一个非空的屏障操做,则在容许其余线程继续运行以前,当前线程将运行该操做。若是在执行屏障操做过程当中发生异常,
则该异常将传播到当前线程中,并将 barrier 置于损坏状态。 返回: 到达的当前线程的索引,其中,索引 getParties() - 1 指示将到达的第一个线程,零指示最后一个到达的线程 抛出: InterruptedException - 若是当前线程在等待时被中断 BrokenBarrierException - 若是另外一个 线程在当前线程等待时被中断或超时,或者重置了 barrier,或者在调用 await 时 barrier 被损坏,抑或因为异常而致使屏障操做(若是存在)失败。
 

  

 
 1 public class CyclicBarrierTest {  
 2   
 3     public static void main(String[] args) throws IOException, InterruptedException {  
 4         //若是将参数改成4,可是下面只加入了3个选手,这永远等待下去  
 5         //Waits until all parties have invoked await on this barrier.   
 6         CyclicBarrier barrier = new CyclicBarrier(3);  
 7   
 8         ExecutorService executor = Executors.newFixedThreadPool(3);  
 9         executor.submit(new Thread(new Runner(barrier, "1号选手")));  
10         executor.submit(new Thread(new Runner(barrier, "2号选手")));  
11         executor.submit(new Thread(new Runner(barrier, "3号选手")));  
12   
13         executor.shutdown();  
14     }  
15 }  
16   
17 class Runner implements Runnable {  
18     // 一个同步辅助类,它容许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)  
19     private CyclicBarrier barrier;  
20   
21     private String name;  
22   
23     public Runner(CyclicBarrier barrier, String name) {  
24         super();  
25         this.barrier = barrier;  
26         this.name = name;  
27     }  
28   
29     @Override  
30     public void run() {  
31         try {  
32             Thread.sleep(1000 * (new Random()).nextInt(8));  
33             System.out.println(name + " 准备好了...");  
34             // barrier的await方法,在全部参与者都已经在此 barrier 上调用 await 方法以前,将一直等待。  
35             barrier.await();  
36         } catch (InterruptedException e) {  
37             e.printStackTrace();  
38         } catch (BrokenBarrierException e) {  
39             e.printStackTrace();  
40         }  
41         System.out.println(name + " 起跑!");  
42     }  
43 }  

输出:ide

3号选手 准备好了...
2号选手 准备好了...
1号选手 准备好了...
1号选手 起跑!
2号选手 起跑!
3号选手 起跑!






同步辅助类----------------------------------------------同步辅助类----------------------------------------------同步辅助类--------------
相关文章
相关标签/搜索