一、常用线程池
1.newCachedThreadPool
(1)缓存型池子，先查看池中有没有以前建立的线程，如果有，就复用，如果没有，就建立一个新的线程加入池中；
(2)缓存型池子，通常用于执行一些生存周期很短的异步型任务；因此一些面向连接的daemon型server中用得不多；
(3)能复用的线程，缺省超时时间是60s,超过这个IDLE时长，线程实例将被终止及移出池。
(4)注意，放入CachedThreadPool的线程不必担心其结束，超过超时时间,其会自动被终止
2.newFixedThreadPool
(1)newFixedThreadPool与cacheThreadPool差不多，也是能复用就用，但不能随时建新的线程
(2)其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子
(3)FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器
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秒，当张三李四都完成后，总任务结束。代码如下：
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
/**
* @author Tom
*/
public class CountDownLatchDemo {
final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(2);
new Worker("张三", 5000, latch).start();
new Worker("李四", 10000, latch).start();
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("all work done at:" + sdf.format(new Date()));
}
static class Worker extends Thread {
String workerName;
int workerTime;
CountDownLatch latch;
public Worker(String workerName,
int workerTime,
CountDownLatch latch) {
this.workerName = workerName;
this.workerTime = workerTime;
this.latch = latch;
}
@Override
public void run() {
System.out.println("worker " + workerName + " do worker begin at:" + sdf.format(new Date()));
doWork();
System.out.println("worker " + workerName + " do worker complete at:" + sdf.format(new Date()));
latch.countDown();
}
private void doWork() {
try {
Thread.sleep(workerTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}worker 李四 do worker begin at:2020-01-19 10:47:02
worker 张三 do worker begin at:2020-01-19 10:47:02
worker 张三 do worker complete at:2020-01-19 10:47:07
worker 李四 do worker complete at:2020-01-19 10:47:12
all work done at:2020-01-19 10:47:12
Process finished with exit code 0测试可见，张三李四共同协作完成。
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个线程同时运行问题。
package com.retail.juc;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* 问题:一个池塘有很多鸟和鱼,鸟每分钟产生一个后代,鱼每30s产生2个后代.
* 鸟每10s吃掉一条鱼.建一个鱼塘,初始化一些鸟和鱼,看看什么时候鸟把鱼吃光
*
* @author Tom
*/
public class CyclicBarrierDemo {
long time;
long birdNum;
long fishNum;
Object lock = new Object();
CyclicBarrier barrier;
public CyclicBarrierDemo(long birdNum, long fishNum) {
this.birdNum = birdNum;
this.fishNum = fishNum;
}
public static void main(String[] args) {
// 初始化5只鸟,20条鱼
CyclicBarrierDemo bf = new CyclicBarrierDemo(5, 20);
bf.start();
}
/**
* 生态圈开启
*/
private void start() {
// 构造鸟,鱼,时间线
FishThread fish = new FishThread();
BirdThread bird = new BirdThread();
TimeLine tl = new TimeLine();
// 初始化环形屏障,当barrier的await被调用2次,执行tl线程
// 如果大于调用的await的线程数,会死锁
barrier = new CyclicBarrier(2, tl);
fish.start();
bird.start();
}
public class FishThread extends Thread {
@Override
public void run() {
// 循环
while (true) {
System.out.println("鱼已经就位,到达await!");
try {
// 进入睡眠,等待所有子任务都进入睡眠,再继续
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
synchronized (lock) {
// 鱼每30s产生2个后代
if (time % 30 == 0) {
fishNum += fishNum * 2;
printInfo("鱼执行动作! ");
}
}
}
}
}
public class BirdThread extends Thread {
@Override
public void run() {
// 循环
while (true) {
System.out.println("鸟已经就位,到达await!");
try {
// 进入睡眠,等待所有子任务都进入睡眠,再继续
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
synchronized (lock) {
// 鸟每10s要吃掉一条鱼
if (time % 10 == 0) {
fishNum = fishNum >= birdNum ? fishNum - birdNum : 0;
// 鸟每分钟产生一个后代
if (time % 60 == 0) {
birdNum += birdNum;
}
printInfo("鸟动作执行! ");
}
}
}
}
}
private class TimeLine implements Runnable {
@Override
public void run() {
System.out.println("TimeLine start!");
if (fishNum <= 0) {
System.exit(-1);
}
// 时间加10s
time += 10;
System.out.println("TimeLine end,时间加10s");
}
}
public void printInfo(String source) {
System.out.printf(source + "time[%d]:birNum[%d],fishNum[%d]\n", time, birdNum, fishNum);
}
}
鱼已经就位,到达await!
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鸟动作执行! time[10]:birNum[5],fishNum[15]
鱼已经就位,到达await!
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[20]:birNum[5],fishNum[10]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼执行动作! time[30]:birNum[5],fishNum[30]
鱼已经就位,到达await!
鸟动作执行! time[30]:birNum[5],fishNum[25]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[40]:birNum[5],fishNum[20]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[50]:birNum[5],fishNum[15]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鸟动作执行! time[60]:birNum[10],fishNum[10]
鸟已经就位,到达await!
鱼执行动作! time[60]:birNum[10],fishNum[30]
鱼已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[70]:birNum[10],fishNum[20]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鸟动作执行! time[80]:birNum[10],fishNum[10]
鸟已经就位,到达await!
鱼已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼执行动作! time[90]:birNum[10],fishNum[30]
鱼已经就位,到达await!
鸟动作执行! time[90]:birNum[10],fishNum[20]
鸟已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鸟动作执行! time[100]:birNum[10],fishNum[10]
鸟已经就位,到达await!
鱼已经就位,到达await!
TimeLine start!
TimeLine end,时间加10s
鱼已经就位,到达await!
鸟动作执行! time[110]:birNum[10],fishNum[0]
鸟已经就位,到达await!
TimeLine start!
Process finished with exit code -1
4.Semaphore
通过控制操作系统的信号量数目来控制并发，比控制线程并发数粒度更细。管理固定数值的信号量，用以控制并发的数量。把需要并发的代码放在acquire、release之间即可。acquire获取信号，release释放信号。如果Semaphore管理一个信号量，就是互斥锁。
package com.retail.juc;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* @author Tom
*/
public class SemaphoreDemo {
public static void main(String[] args) {
// 线程池
ExecutorService exec = Executors.newCachedThreadPool();
// 只能5个线程同时访问
final Semaphore semp = new Semaphore(5);
// 模拟20个客户端同时访问
for (int i = 0; i < 20; i++) {
final int NO = i;
Runnable run = () -> {
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();
}
}
"C:\Program Files\Java\jdk1.8.0_111\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.1\lib\idea_rt.jar=65069:C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.1\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_111\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\rt.jar;D:\study\out\production\study" com.retail.juc.SemaphoreDemo
accessing: 0
accessing: 2
accessing: 3
accessing: 1
accessing: 4
------------------------5
accessing: 5
accessing: 9
accessing: 6
------------------------5
------------------------5
------------------------5
------------------------5
accessing: 8
accessing: 7
------------------------2
accessing: 10
------------------------2
accessing: 11
------------------------1
accessing: 12
------------------------1
accessing: 13
------------------------2
accessing: 14
------------------------1
accessing: 15
------------------------2
accessing: 16
accessing: 17
------------------------2
------------------------1
accessing: 18
------------------------1
accessing: 19
------------------------1
------------------------2
------------------------3
------------------------4
------------------------5
Process finished with exit code 0
5.Exchanger
用于两个线程之间进行数据交换，先执行exchanger.exchange()的线程等待后来的线程到达，然后交换数据，最后再继续向下执行。
package com.retail.juc;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Exchanger;
/**
* @author Tom
*/
public class ExchangerDemo {
public static void main(String[] args) {
Exchanger<List<Integer>> exchanger = new Exchanger<>();
new Thread(() -> {
List<Integer> 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();
new Thread(() -> {
List<Integer> 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();
}
}
Thread2 [1, 2]
Thread1 [3, 4]
Process finished with exit code 0
6.Future和FutrueTask
Future是接口，FutrueTask是接口实现类。场景：多线程并发执行，返回结果放进list.
package com.retail.juc;
import java.util.ArrayList;
import java.util.concurrent.*;
/**
* @author Tom
*/
public class FutureDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 结果集
ArrayList<Integer> list = new ArrayList<>();
// 开启线程池
ExecutorService exec = Executors.newFixedThreadPool(3);
ArrayList<Future<Integer>> futureList = new ArrayList<>();
// 启动线程池,固定线程数3
for (int i = 0; i < 3; i++) {
// 提交任务,添加返回
futureList.add(exec.submit(() -> 1));
}
// 结果归集
for (Future<Integer> future : futureList) {
list.add(future.get());
}
System.out.println("list=" + list);
}
}
list=[1, 1, 1]
扫一扫
287
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
