java线程池调方法 java线程池调度

转载

attitude 2023-08-02 20:39:39

文章标签 java线程池调方法线程池调度 java java fish System 文章分类 Java 后端开发

众所周知，开启线程2种方法：第一是实现Runable接口，第二继承Thread类。(当然内部类也算...)常用的，这里就不再赘述。

一、线程池

1.newCachedThreadPool

(1)缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse，如果没有，就建立一个新的线程加入池中；

(2)缓存型池子，通常用于执行一些生存周期很短的异步型任务；因此一些面向连接的daemon型server中用得不多；

(3)能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。

(4)注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止

2.newFixedThreadPool--本人常用

(1)newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程

(2)其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子

(3)和cacheThreadPool不同，FixedThreadPool没有IDLE机制(可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的)，所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器

(4)从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同:

fixed池线程数固定，并且是0秒IDLE(无IDLE)

cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力)，60秒IDLE

3.ScheduledThreadPool

(1)调度型线程池

(2)这个池子里的线程可以按schedule依次delay执行，或周期执行

4.SingleThreadExecutor

(1)单例线程，任意时间池中只能有一个线程

(2)用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE(无IDLE)

二、常用线程调度类

1.wait、notify、notifyAll-----不建议新手直接使用

顾名思义，wait是等待，notify是通知一个等待线程、notifyAll唤醒所有等待线程。

2.CountDownLatch----很适合用来将一个任务分为n个独立的部分，等这些部分都完成后继续接下来的任务

隶属于java.util.concurrent包。CountDownLatch类是一个同步计数器,构造时传入int参数,该参数就是计数器的初始值，每调用一次countDown()方法，计数器减1,计数器大于0 时，await()方法会阻塞程序继续执行.当多个线程达到预期时(latch.countDown())，唤醒多个其他等待中的线程，即执行latch.await()后面的代码。样例是，张三、李四合作完成任务，张三5秒，李四8秒，当张三李四都完成后，总任务结束。代码如下：

importjava.text.SimpleDateFormat;importjava.util.Date;importjava.util.concurrent.CountDownLatch;public classCountDownLatchDemo {final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");public static void main(String[] args) throwsInterruptedException {
CountDownLatch latch=new CountDownLatch(2);//两个工人的协作
Worker worker1=new Worker("张三", 5000, latch);
Worker worker2=new Worker("李四", 8000, latch);
worker1.start();
worker2.start();
latch.await();//阻塞！等待所有工人完成工作
System.out.println("all work done at "+sdf.format(newDate()));
}static class Worker extendsThread{
String workerName;intworkTime;
CountDownLatch latch;public Worker(String workerName ,intworkTime ,CountDownLatch latch){this.workerName=workerName;this.workTime=workTime;this.latch=latch;
}public voidrun(){
System.out.println("Worker "+workerName+" do work begin at "+sdf.format(newDate()));
doWork();//工作了
System.out.println("Worker "+workerName+" do work complete at "+sdf.format(newDate()));
latch.countDown();//工人完成工作，计数器减一
}private voiddoWork(){try{
Thread.sleep(workTime);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}

-----------------------------------------------

Worker 李四 do work begin at 2016-11-02 18:25:28

Worker 张三 do work begin at 2016-11-02 18:25:28

Worker 张三 do work complete at 2016-11-02 18:25:33

Worker 李四 do work complete at 2016-11-02 18:25:36

all work done at 2016-11-02 18:25:36

测试可见，张三李四共同协作完成。

3.CyclicBarrier----适合多线程循环到达屏障后再执行

字面意思循环屏障，可理解为栅栏，协同多个线程都执行到barrier.await时，如果构造CyclicBarrier barrier=new CyclicBarrier(2, Runnable)时，第一个参数代码线程数，如果有第二参Runnable,那么所有线程都await时，先执行Runnable，再各自执行await后续的代码。

CyclicBarrier和CountDownLatch区别：

1.CountDownLatch在多个线程都执行完毕latch.countDown后唤醒await线程，多个countDown子线程在执行完countDown后可继续执行后续代码。

2.CyclicBarrier可循环使用，CountDownLatch只1次。见代码示例：

3.CountDownLatch需要latch.countDown和latch.await()配合使用。CyclicBarrier就一个barrier.await。

下面举例：鸟、鱼2个线程同时运行问题。

1 packagestudy.thread;2
3 importjava.util.concurrent.BrokenBarrierException;4 importjava.util.concurrent.CyclicBarrier;5
6 /**
7 * 循环栅栏(屏障)8 * 问题：一个池塘，有很多鸟和很多鱼，鸟每分钟产生一个后代，鱼每30秒钟产生2个后代。9 * 鸟每10秒钟要吃掉一条鱼。建一个池塘，初始化一些鱼和鸟，看看什么时候鸟把鱼吃光。10 *11 */
12 public classCyclicBarrierDemo {13
14 longtime ;15 longbirdNum ;16 longfishNum ;17 Object lock = newObject() ;18 CyclicBarrier barrier ;19
20 public CyclicBarrierDemo(long birdNum , longfishNum){21 this.birdNum =birdNum ;22 this.fishNum =fishNum ;23 }24
25 /**
26 * 入口27 *@paramargs28 */
29 public static voidmain(String[] args) {30 //构造demo,初始化5只秒，20条鱼
31 CyclicBarrierDemo bf = new CyclicBarrierDemo(5 , 20) ;32 //生态圈开启
33 bf.start();34 }35
36 //生态圈开启
37 public voidstart(){38 //构造鱼，鸟，时间线
39 FishThread fish = newFishThread() ;40 BirdThread bird = newBirdThread() ;41 TimeLine tl = newTimeLine() ;42
43 //初始化环形屏障，当barrier对象的await方法被调用两次之后，将会执行tl线程
44 barrier = new CyclicBarrier(2, tl) ;//这里要注意第一个参数，如果大于调用await的线程数，会死锁。45
46 //鱼、鸟动起来
47 fish.start();48 bird.start();49
50 }51
52 public voidprintInfo(String source){53 System.out.printf(source+"time[%d]:birdNum[%d] ,fishNum[%d]\n",time , birdNum , fishNum);54 }55
56 private class TimeLine implementsRunnable {57 @Override58 public void run() { //所有子任务都调用了await方法后，将会执行该方法， 然后所有子线程继续执行
59 System.out.println("TimeLine start!");60 //如果鱼数量<=0,结束程序
61 if(fishNum <= 0){62 System.exit(-1);63 }64 //时间加10秒
65 time += 10;66 System.out.println("TimeLine end，时间加10秒！");67 }68 }69
70 private class FishThread extendsThread {71 @Override72 public voidrun() {73 //循环
74 while(true){75 try{76 System.out.println("鱼已经就位！到达await!");77 barrier.await() ; //进入睡眠， 等待所有子任务都进入睡眠 然后再继续
78 } catch (InterruptedException |BrokenBarrierException e) {79 e.printStackTrace();80 }81 synchronized(lock) {82 //鱼每30秒钟产生2个后代
83 if(time % 30 == 0){84 fishNum += fishNum * 2;85 printInfo("鱼动作执行！");86 }87 }88 }89 }90 }91
92 private class BirdThread extendsThread{93 @Override94 public voidrun() {95 //循环
96 while(true){97 try{98 System.out.println("鸟已经就位！到达await!");99 barrier.await() ; //进入睡眠， 等待所有子任务都进入睡眠 然后再继续
100 } catch (InterruptedException |BrokenBarrierException e) {101 e.printStackTrace();102 }103 synchronized(lock) {104 //鸟每10秒钟要吃掉一条鱼
105 if(time % 10 == 0){106 fishNum = fishNum >= birdNum ? fishNum - birdNum : 0;107 //鸟每分钟产生一个后代
108 if(time % 60 == 0){109 birdNum +=birdNum ;110 }111 printInfo("鸟动作执行！");112 }113 }114
115 }116
117 }118
119 }120
121 }

4.Semaphore---通过控制操作系统的信号量数目来控制并发，比控制线程并发数粒度更细。

管理固定数值的信号量，用以控制并发的数量。把需要并发的代码放在acquire、release之间即可。acquire获取信号，release释放信号。如果Semaphore管理一个信号量，就是互斥锁。

importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;importjava.util.concurrent.Semaphore;public classSemaphoreTest {public static voidmain(String[] args) {//线程池
ExecutorService exec =Executors.newCachedThreadPool();//只能5个线程同时访问
final Semaphore semp = new Semaphore(5);//模拟20个客户端访问
for (int index = 0; index < 20; index++) {final int NO =index;
Runnable run= newRunnable() {public voidrun() {try{//获取许可
semp.acquire();
System.out.println("Accessing: " +NO);
Thread.sleep(2000);
}catch(InterruptedException e) {
e.printStackTrace();
}finally{//释放
semp.release();
System.out.println("-----------------"+semp.availablePermits());
}
}
};
exec.execute(run);
}//退出线程池
exec.shutdown();
}
}

5.Exchanger

用于两个线程之间进行数据交换，先执行exchanger.exchange()的线程等待后来的线程到达，然后交换数据，最后再继续向下执行。

importjava.util.ArrayList;importjava.util.List;importjava.util.concurrent.Exchanger;/***
* @ClassName: ExchangerDemo
* @Description: 用于两个线程之间进行数据交换，先执行exchanger.exchange()的线程等待后来的线程到达，然后交换数据，最后再继续向下执行。
*@authordenny.zhang
* @date 2016年11月4日 下午1:27:29
**/
public classExchangerDemo {public static voidmain(String[] args) {final Exchanger> exchanger = new Exchanger>();newThread(){public voidrun(){
List list = new ArrayList();
list.add(1);
list.add(2);try{
list=exchanger.exchange(list);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread1"+list);
}
}.start();newThread(){public voidrun(){
List list = new ArrayList();
list.add(3);
list.add(4);try{
list=exchanger.exchange(list);
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread2"+list);
}
}.start();
}
}

6.Future和FutrueTask---常用！

Future是接口，FutrueTask是接口实现类。场景：多线程并发执行，返回结果放进list.

importjava.util.ArrayList;importjava.util.List;importjava.util.concurrent.Callable;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;importjava.util.concurrent.Future;/***
* @ClassName: FutureDemo
* @Description: Future
*@authordenny.zhang
* @date 2016年11月4日 下午1:50:32
**/
public classFutureDemo {public static void main(String[] args) throwsInterruptedException, ExecutionException {//结果集
List list = new ArrayList();//开启多线程
ExecutorService exs = Executors.newFixedThreadPool(3);
List> futureList = new ArrayList>();//启动线程池，固定线程数为3
for(int i=0;i<3;i++){//提交任务，添加返回
futureList.add(exs.submit(new Callable() {
@Override
public Integer call() throws Exception {
return 1;
}
}));
}//结果归集
for (Futurefuture : futureList) {while (true) {if (future.isDone()&& !future.isCancelled()) {
Integer i=future.get();
list.add(i);break;
}else{
Thread.sleep(100);
}
}
}
System.out.println("list="+list);
}
}

返回：list=[1, 1, 1]

====================================

参考：

《大型网站系统与java中间件实践》

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。