JUC
java.util.concurrent :concrrent包
java.util.concurrent.atomic :原子包
java.util.concurrent.;locks :锁lock包
lock 锁
package com.bin.concurrent;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Resources {
private int num = 30;
private Lock lock = new ReentrantLock();//可重入锁
public void subtractNum() {
lock.lock();
try {
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "售卖前:" + (num--) + "售卖后:num=" + num);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
/**
* 1.高内聚低耦合的情况下: 线程 操作(对外暴露的调用方法) 资源类
* 2.判断 / 干活 / 通知
* 3.多线程交互中,必须要防止多线程的虚假唤醒,必须用while 不能用if
*
* @Author: 邱成兵
* @Date: Created in 19:30 2021/4/27
*/
public class SaleTicket {
public static void main(String[] args) {
Resources resources = new Resources();
new Thread(() -> {
for (int i = 0; i < 40; i++) resources.subtractNum();
}, "A").start();
new Thread(() -> {
for (int i = 0; i < 40; i++) resources.subtractNum();
}, "B").start();
new Thread(() -> {
for (int i = 0; i < 40; i++) resources.subtractNum();
}, "C").start();
/*new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 40; i++) {
resources.subtractNum();
}
}
},"A").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 40; i++) {
resources.subtractNum();
}
}
},"B").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 40; i++) {
resources.subtractNum();
}
}
},"C").start();*/
}
}
package com.bin.concurrent;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class ShareResource {
private int number=1;//A:1 B:2 C:3
private Lock lock=new ReentrantLock();//可重入锁
private Condition condition1=lock.newCondition();
private Condition condition2=lock.newCondition();
private Condition condition3=lock.newCondition();
public void print5(){
lock.lock();
try {
//判断
if(number!=1){
condition1.await();
}
//干活
for (int i = 1; i <=5 ; i++) {
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
number=2;
//通知
condition2.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void print10(){
lock.lock();
try {
//判断
if(number!=2){
condition2.await();
}
//干活
for (int i = 1; i <=10 ; i++) {
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
number=3;
//通知
condition3.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void print15(){
lock.lock();
try {
//判断
if(number!=3){
condition3.await();
}
//干活
for (int i = 1; i <=15 ; i++) {
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
number=1;
//通知
condition1.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
/**
* 精准唤醒
* 1.高内聚低耦合的情况下: 线程 操作(对外暴露的调用方法) 资源类
* 2.判断 / 干活 / 通知
* 3.多线程交互中,必须要防止多线程的虚假唤醒,必须用while 不能用if
* 4.标志位
*
* @Author: 邱成兵
* @Date: Created in 11:03 2021/4/30
*/
public class ThreadOrderAccess {
public static void main(String[] args) {
ShareResource shareResource=new ShareResource();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
shareResource.print5();
}
}, "A").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
shareResource.print10();
}
}, "B").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
shareResource.print15();
}
}, "C").start();
}
}
package com.bin.concurrent;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class AirConditioner{
private int num=0;
private Lock lock=new ReentrantLock();//可重入锁
//代替 synchronized 里面的 wait notify notifyall 方法 awati signal signalAll
private Condition condition=lock.newCondition();
public void addNum() throws InterruptedException {
lock.lock();
try {
while (num!=0){
// wait();
condition.await();
}
num++;
System.out.println(Thread.currentThread().getName() +"生产" +num);
// notify();
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void subtractNum() throws InterruptedException {
lock.lock();
try {
//判断
while(num==0){
// wait();
condition.await();
}
//干活
num--;
System.out.println(Thread.currentThread().getName() +"消费"+num);
// notify();
//通知
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
/**
* 老版本
*
**/
/*public synchronized void addNum() throws InterruptedException {
while (num>0){
wait();
}
num++;
System.out.println(Thread.currentThread().getName() +"生产" +num);
notify();
}
public synchronized void subtractNum() throws InterruptedException {
while(num<=0){
wait();
}
num--;
System.out.println(Thread.currentThread().getName() +"消费"+num);
notify();
}*/
}
/**
* 交替打印出消费数字
* 2.判断 / 干活 / 通知
* 3.多线程交互中,必须要防止多线程的虚假唤醒,必须用while 不能用if
*
* @Author: 邱成兵
* @Date: Created in 11:18 2021/4/28
*/
public class ThreadWaitNotifyDemo {
public static void main(String[] args) {
AirConditioner airConditioner=new AirConditioner();
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
airConditioner.addNum();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "A").start();
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
airConditioner.subtractNum();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "B").start();
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
airConditioner.addNum();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "C").start();
new Thread(() -> {
try {
for (int i = 0; i < 10; i++) {
airConditioner.subtractNum();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "D").start();
}
}
多线程8锁
同步方法,锁是当前this
静态同步方法,锁是当前对象的.class
同步方法块,锁是()里传的对象,结束或异常必须释放锁
普通方法,互不影响
线程异常
java.util.concurrentModificationException 并发修改异常
Arraylist 如何线程安全
- 用vector集合
- Collections.synchronizedList(new ArrayList<>()) Collections工具类
- CopyOnWriteArrayList-写时复制(读写分离思想) concrrent并发包下
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
每次添加进来先拿到锁, 先拿到以前的集合,再获取长度,在扩容+1,把添加的数据放入扩容过后的集合,再放入以前的集合,并通知下一个-标志位
集合扩容是一半 map扩容是一倍2*n次方 每次加1
并发经验:如果能确认map的大小直接给确定值,避免后续再扩容操作
安全的集合和map
package com.bin.concurrent;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
/**
* 线程安全
* 1.故障现象: java.util.ConCurrentModificationException
* 2.导致原因: 线程不安全导致的
* 3.解决方案: 线程安全的集合或map 集合工具类 collections 并发包:concurrent
* 4.优化建议: (同样的错误 不出现第二次)
*
* @Author: qcb
* @Date: Created in 11:47 2021/5/6
*/
public class NotSafeDemo {
public static void mapNotSafe() {
// 线程安全的map
Map<Object, Object> collections = new ConcurrentHashMap<>();//Collections.synchronizedMap()//new HashMap<>();
for (int i = 0; i < 30; i++) {
new Thread(() -> {
collections.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0, 8));
System.out.println(collections);
}, String.valueOf(i)).start();
}
}
public static void setNotSafe() {
// 线程安全的set
Set<String> collections = new CopyOnWriteArraySet(); //Collections.synchronizedSet(new HashSet<>())//new HashSet<>();
for (int i = 0; i < 30; i++) {
new Thread(() -> {
collections.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(collections);
}, String.valueOf(i)).start();
}
}
public static void listNotSafe(){
// 线程安全的list
List<String> collections= new CopyOnWriteArrayList();//Collections.synchronizedList()//new Vector<>();//new ArrayList<>();
for (int i = 0; i <30 ; i++) {
new Thread(() -> {
collections.add(UUID.randomUUID().toString().substring(0,8));
System.out.println(collections);
}, String.valueOf(i)).start();
}
}
}
多线程
- 创建多线程的方式:
- 传统有2种,java5之后增加了2种 总共4种
callable 细节
package com.bin.concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class MyThread implements Callable<Integer> {
@Override
public Integer call() throws Exception {
System.out.println("come in here");
return 1024;
}
}
/**
* @Author: 邱成兵
* @Date: Created in 15:15 2021/5/6
* 获取多线程的方式
* 1.继承Thread
* 2.实现runnable
* 3.实现callable<>
* 4.线程池
*/
public class CallableDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask futureTask = new FutureTask(new MyThread());
//实现原理 java 多态
new Thread(futureTask, "A").start();
//多次调用 走的是缓存 只会调用一次
//new Thread(futureTask, "B").start();
//获取结果一定要放到最后 不然会阻塞拿到结果在执行
System.out.println(futureTask.get());
}
}
辅助类
CountDownLatch 辅助类-减少计数
作用: 是一种通用的同步工具 等其他线程执行完了 主线程再关闭 关门走人
原理:
- CountDownLatch主要有两个方法,当一个或多个线程调用await方法时,这些线程会阻塞。 * 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞), * 当计数器的值变为0时,因await方法阻塞的线程会被唤醒,继续执行。
package com.bin.concurrent;
import java.util.concurrent.CountDownLatch;
/**
* JUC辅助类
* @Author: 邱成兵
* @Date: Created in 16:09 2021/5/6
*/
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
//减少计数 开始初始 第一个是启动信号,防止任何工作人员进入,直到驾驶员准备好继续前进;
CountDownLatch countDownLatch=new CountDownLatch(6);
for (int i = 0; i < 6; i++) {
new Thread(() -> {
System.out.println("第"+Thread.currentThread().getName()+"个同学出教室 /t");
countDownLatch.countDown();
}, String.valueOf(i)).start();
}
//第二个是完成信号,允许司机等到所有的工作人员完成。
countDownLatch.await();
System.out.println("关门");
}
}
CyclicBarrier 辅助类-循环栅栏 到达共同屏障点的同步辅助
允许一组线程全部等待彼此达到共同屏障点的同步辅助 集齐7龙珠
原理:
- CyclicBarrier * 的字面意思是可循环(Cyclic)使用的屏障(Barrier)。它要做的事情是, * 让一组线程到达一个屏障(也可以叫同步点)时被阻塞, * 直到最后一个线程到达屏障时,屏障才会开门,所有 * 被屏障拦截的线程才会继续干活。 * 线程进入屏障通过CyclicBarrier的await()方法。
package com.bin.concurrent;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* 允许一组线程全部等待彼此达到共同屏障点的同步辅助
*
* @Author: 邱成兵
* @Date: Created in 16:53 2021/5/6
*/
public class CyclicBarrierDemo {
public static void main(String[] args) {
//参数1:多少个线程跳闸 参数2:跳闸之后执行的线程
CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
System.out.println("集齐7颗龙珠");
});
for (int i = 0; i < 7; i++) {
final int temInt=i;
new Thread(() -> {
System.out.println(Thread.currentThread().getName()+" /t 第" +temInt+"颗龙珠");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}, String.valueOf(i)).start();
}
}
}
semaphore -辅助类-信号灯
可做秒杀线程数量控制 不管前端请求多少个 只接受固定能接受的数量
主要用于并发的控制可资源的互斥 限流
如果设置semaphore 为1 等同于 synchronized (场景 一个线程持有一个资源多久 可以用这个实现)
原理:
在信号量上我们定义两种操作: * acquire(获取) 当一个线程调用acquire操作时,它要么通过成功获取信号量(信号量减1), * 要么一直等下去,直到有线程释放信号量,或超时。 * release(释放)实际上会将信号量的值加1,然后唤醒等待的线程。 * * 信号量主要用于两个目的,一个是用于多个共享资源的互斥使用,另一个用于并发线程数的控制。
package com.bin.concurrent;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 信号等
* 用户并发的控制和资源的互斥 限流
* @Author: 邱成兵
* @Date: Created in 17:15 2021/5/6
*/
public class SemaphoreDemo {
public static void main(String[] args) {
//模拟3个车位
Semaphore semaphore=new Semaphore(3);
for (int i = 0; i < 6; i++) {
new Thread(() -> {
//资源减一
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"/t 抢到了车位");
try {
TimeUnit.SECONDS.sleep(3);
}catch (Exception e){
}
System.out.println(Thread.currentThread().getName()+"/t 退出停车位");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//释放资源
semaphore.release();
}
}, String.valueOf(i)).start();
}
}
}
ReadWriteLock 读写锁 (场景:缓存的读写)
读读能共存 读写不能共存 写写不能共存
package com.bin.concurrent;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class MyCache{
private volatile Map<String,Object> map=new HashMap<>();
//读写锁
private ReadWriteLock lock=new ReentrantReadWriteLock();
public void put(String key,Object value){
try {
lock.writeLock().lock();
System.out.println(key+" /t 开始写入数据");
TimeUnit.MILLISECONDS.sleep(3);
map.put(key,value);
System.out.println(key+" /t 写入完成"+value);
}catch (Exception e){
e.printStackTrace();
}finally {
lock.writeLock().unlock();
}
}
public void get(String key) {
try {
lock.readLock().lock();
System.out.println(key+" /t 开始读数据");
TimeUnit.MILLISECONDS.sleep(3);
Object o = map.get(key);
System.out.println(key+" /t 读取读数据"+o);
}catch (Exception e){
e.printStackTrace();
}finally {
lock.readLock().unlock();
}
}
}
/**
* 读写锁
* @Author: 邱成兵
* @Date: Created in 10:32 2021/5/7
*/
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache=new MyCache();
for (int i = 0; i < 5; i++) {
myCache.put(i+"",i+"");
}
for (int i = 0; i < 5; i++) {
myCache.get(i+"");
}
}
}
BlockingQueue - 阻塞队列
不用手动阻塞、唤醒线程了 (wait/await notify/signal notifyall/signalAll) BlockingQueue全部自动实现了
核心方法
package com.bin.concurrent;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
/**
* 阻塞队列
* @Author: 邱成兵
* @Date: Created in 14:35 2021/5/7
*/
public class BlockingQueueDemo {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> blockingQueue=new ArrayBlockingQueue<>(3);
blockingQueue.add("a");//添加 超过界限会报异常 queue full :队列已满
blockingQueue.remove();//移除先进的第一位 没有会报异常
blockingQueue.element();//检查 没有会报异常
blockingQueue.offer("a"); //超出返回false
blockingQueue.poll(); //没有移除的返回 null
blockingQueue.peek();//检查 没有返回null
blockingQueue.put("a");//添加 超出会阻塞
blockingQueue.take();//移除 没有会阻塞
blockingQueue.offer("a",3l, TimeUnit.SECONDS);//超出多少时间后直接退出
blockingQueue.poll(3l, TimeUnit.SECONDS);//超出多少时间后直接退出
}
}
线程池
例子:10年前单核CPU电脑,假的多线程,像马戏团小丑玩多个球,CPU需要来回切换。现在是多核电脑,多个线程各自跑在独立的CPU上,不用切换效率高。
线程池的优势:线程池做的工作只要是控制运行的线程数量,处理过程中将任务放入队列,然后在线程创建后启动这些任务,如果线程数量超过了最大数量,超出数量的线程排队等候,等其他线程执行完毕,再从队列中取出任务来执行。
它的主要特点为:线程复用;控制最大并发数;管理线程。
第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
第二:提高响应速度。当任务到达时,任务可以不需要等待线程创建就能立即执行。
第三:提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会销耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
package com.bin.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 线程池三大主流使用方法
* @Author: 邱成兵
* @Date: Created in 15:59 2021/5/7
*/
public class ThreadDemo {
public static void main(String[] args) {
//执行长期任务性能好,创建一个线程池,一池有N个固定的线程,有固定线程数的线程
// ExecutorService executorService= Executors.newFixedThreadPool(5);
//一个任务一个任务的执行,一池一线程
// ExecutorService executorService= Executors.newSingleThreadExecutor();
//执行很多短期异步任务,线程池根据需要创建新线程,但在先前构建的线程可用时将重用它们。可扩容,遇强则强
ExecutorService executorService= Executors.newCachedThreadPool();
try {
for (int i = 1; i <= 10; i++) {
final int teamInt=i;
executorService.execute(()->{
System.out.println(Thread.currentThread().getName()+" /t 办理业务"+teamInt);
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
executorService.shutdown();
}
}
}
7大参数详解
1、corePoolSize:线程池中的常驻核心线程数
2、maximumPoolSize:线程池中能够容纳同时
执行的最大线程数,此值必须大于等于1
3、keepAliveTime:多余的空闲线程的存活时间
当前池中线程数量超过corePoolSize时,当空闲时间
达到keepAliveTime时,多余线程会被销毁直到
只剩下corePoolSize个线程为止
4、unit:keepAliveTime的单位
5、workQueue:任务队列,被提交但尚未被执行的任务
6、threadFactory:表示生成线程池中工作线程的线程工厂,
用于创建线程,一般默认的即可
7、handler:拒绝策略,表示当队列满了,并且工作线程大于
等于线程池的最大线程数(maximumPoolSize)时如何来拒绝
请求执行的runnable的策略
线程池底层工作原理
工作底层原理步骤
- 提交任务
- 判断核心线程是否满 满:进入队列
- 判断阻塞队列是否满 满:创建主线程 (一个一个的扩)
- 判断主线程是否满 满:拒绝策略
1、在创建了线程池后,开始等待请求。
2、当调用execute()方法添加一个请求任务时,线程池会做出如下判断:
2.1、如果正在运行的线程数量小于corePoolSize,那么马上创建线程运行这个任务;
2.2、如果正在运行的线程数量大于或等于corePoolSize,那么将这个任务放入队列;
2.3、如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize,那么还是要创建非核心线程立刻运行这个任务;
2.4、如果队列满了且正在运行的线程数量大于或等于maximumPoolSize,那么线程池会启动饱和拒绝策略来执行。
3、当一个线程完成任务时,它会从队列中取下一个任务来执行。
4、当一个线程无事可做超过一定的时间(keepAliveTime)时,线程会判断: 如果当前运行的线程数大于corePoolSize,那么这个线程就被停掉。 所以线程池的所有任务完成后,它最终会收缩到corePoolSize的大小。
工作中常用创建的线程池方法
在工作中单一的/固定数的/可变的三种创建线程池的方法哪个用的多?
一个都不用,我们工作中只能使用自定义的
OOM(OutOfMemoryError? -JAVA内存溢出 虚拟机暴露故障
ExecutorService executorService=new ThreadPoolExecutor(2,//核心
5,//主线程
2L,//过期时间
TimeUnit.SECONDS,//过期单位
new LinkedBlockingQueue<>(3),//队列类型 和 队列的大小
Executors.defaultThreadFactory(), //线程工厂 一般都是用默认的
new ThreadPoolExecutor.AbortPolicy());//拒绝策略
4大拒绝策略
- AbortPolicy(默认):直接抛出RejectedExecutionException异常阻止系统正常运行
- CallerRunsPolicy:“调用者运行”一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将某些任务回退到调用者,从而降低新任务的流量。
- DiscardOldestPolicy:抛弃队列中等待最久的任务,然后把当前任务加人队列中尝试再次提交当前任务。
- DiscardPolicy:该策略默默地丢弃无法处理的任务,不予任何处理也不抛出异常。如果允许任务丢失,这是最好的一种策略。
最大线程数该如何设置?
public static void main(String[] args) {
//cpu的数量
int cpuNum = Runtime.getRuntime().availableProcessors();
//cpu密集型 内核数+1或+2
//IO密集型 1/总核数/阻塞系数
ExecutorService executorService=new ThreadPoolExecutor(2,//核心
5,//主线程
2L,//过期时间
TimeUnit.SECONDS,//过期单位
new LinkedBlockingQueue<>(3),//队列类型 和 队列的大小
Executors.defaultThreadFactory(), //线程工厂 一般都是用默认的
new ThreadPoolExecutor.AbortPolicy());//拒绝策略 默认抛出异常
}
一:CPU密集型:
定义:CPU密集型也是指计算密集型,大部分时间用来做计算逻辑判断等CPU动作的程序称为CPU密集型任务。该类型的任务需要进行大量的计算,主要消耗CPU资源。
这种计算密集型任务虽然也可以用多任务完成,但是任务越多,花在任务切换的时间就越多,CPU执行任务的效率就越低,所以,要最高效地利用CPU,计算密集型任务同时进行的数量应当等于CPU的核心数。(或者加1到2)
特点:
01:CPU 使用率较高(也就是经常计算一些复杂的运算,逻辑处理等情况)非常多的情况下使用
02:针对单台机器,最大线程数一般只需要设置为CPU核心数的线程个数就可以了
03:这一类型多出现在开发中的一些业务复杂计算和逻辑处理过程中。
package pool;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Demo02 {
public static void main(String[] args) {
//自定义线程池! 工作中只会使用 ThreadPoolExecutor
/**
* 最大线程该如何定义(线程池的最大的大小如何设置!)
* 1、CPU 密集型,几核,就是几,可以保持CPU的效率最高!
*/
//获取电脑CPU核数
System.out.println(Runtime.getRuntime().availableProcessors()); //8核
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
2, //核心线程池大小
Runtime.getRuntime().availableProcessors(), //最大核心线程池大小(CPU密集型,根据CPU核数设置)
3, //超时了没有人调用就会释放
TimeUnit.SECONDS, //超时单位
new LinkedBlockingDeque<>(3), //阻塞队列
Executors.defaultThreadFactory(), //线程工厂,创建线程的,一般不用动
new ThreadPoolExecutor.AbortPolicy()); //银行满了,还有人进来,不处理这个人的,抛出异常
try {
//最大承载数,Deque + Max (队列线程数+最大线程数)
//超出 抛出 RejectedExecutionException 异常
for (int i = 1; i <= 9; i++) {
//使用了线程池之后,使用线程池来创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//线程池用完,程序结束,关闭线程池
threadPool.shutdown(); //(为确保关闭,将关闭方法放入到finally中)
}
}
}
二:IO密集型:
定义:IO密集型任务指任务需要执行大量的IO操作,涉及到网络、磁盘IO操作,对CPU消耗较少,其消耗的主要资源为IO。
我们所接触到的 IO ,大致可以分成两种:磁盘 IO和网络 IO。
01:磁盘 IO ,大多都是一些针对磁盘的读写操作,最常见的就是文件的读写,假如你的数据库、 Redis 也是在本地的话,那么这个也属于磁盘 IO。
02:网络 IO ,这个应该是大家更加熟悉的,我们会遇到各种网络请求,比如 http 请求、远程数据库读写、远程 Redis 读写等等。
IO 操作的特点就是需要等待,我们请求一些数据,由对方将数据写入缓冲区,在这段时间中,需要读取数据的线程根本无事可做,因此可以把 CPU
时间片让出去,直到缓冲区写满。既然这样,IO 密集型任务其实就有很大的优化空间了(毕竟存在等待):
CPU 使用率较低,程序中会存在大量的 I/O 操作占用时间,导致线程空余时间很多,所以通常就需要开CPU核心数两倍的线程。当线程进行 I/O 操作 CPU
空闲时,线程等待时间所占比例越高,就需要越多线程,启用其他线程继续使用 CPU,以此提高 CPU 的使用率;线程 CPU
时间所占比例越高,需要越少的线程,这一类型在开发中主要出现在一些计算业务频繁的逻辑中
package pool;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Demo02 {
public static void main(String[] args) {
//自定义线程池! 工作中只会使用 ThreadPoolExecutor
/**
* 最大线程该如何定义(线程池的最大的大小如何设置!)
* 2、IO 密集型 >判断你程序中十分耗IO的线程
* 程序 15个大型任务 io十分占用资源! (最大线程数设置为30)
* 设置最大线程数为十分耗io资源线程个数的2倍
*/
//获取电脑CPU核数
System.out.println(Runtime.getRuntime().availableProcessors()); //8核
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
2, //核心线程池大小
16, //若一个IO密集型程序有15个大型任务且其io十分占用资源!(最大线程数设置为 2*CPU 数目)
3, //超时了没有人调用就会释放
TimeUnit.SECONDS, //超时单位
new LinkedBlockingDeque<>(3), //阻塞队列
Executors.defaultThreadFactory(), //线程工厂,创建线程的,一般不用动
new ThreadPoolExecutor.DiscardOldestPolicy()); //队列满了,尝试和最早的竞争,也不会抛出异常
try {
//最大承载数,Deque + Max (队列线程数+最大线程数)
//超出 抛出 RejectedExecutionException 异常
for (int i = 1; i <= 9; i++) {
//使用了线程池之后,使用线程池来创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//线程池用完,程序结束,关闭线程池
threadPool.shutdown(); //(为确保关闭,将关闭方法放入到finally中)
}
}
}
总结:
1:高并发、任务执行时间短的业务,线程池线程数可以设置为CPU核数+1,减少线程上下文的切换
2:并发不高、任务执行时间长的业务这就需要区分开看了:
a)假如是业务时间长集中在IO操作上,也就是IO密集型的任务,因为IO操作并不占用CPU,所以不要让所有的CPU闲下来,可以适当加大线程池中的线程数目,让CPU处理更多的业务
b)假如是业务时间长集中在计算操作上,也就是计算密集型任务,这个就没办法了,线程池中的线程数设置得少一些,减少线程上下文的切换
(其实从一二可以看出无论并发高不高,对于业务中是否是cpu密集还是I/O密集的判断都是需要的当前前提是你需要优化性能的前提下)
3:并发高、业务执行时间长,解决这种类型任务的关键不在于线程池而在于整体架构的设计,看看这些业务里面某些数据是否能做缓存是第一步,我们的项目使用的时redis作为缓存(这类非关系型数据库还是挺好的)。增加服务器是第二步(一般政府项目的首先,因为不用对项目技术做大改动,求一个稳,但前提是资金充足),至于线程池的设置,设置参考
2
。最后,业务执行时间长的问题,也可能需要分析一下,看看能不能使用中间件(任务时间过长的可以考虑拆分逻辑放入队列等操作)对任务进行拆分和解耦。三.:总结:
01:一个计算为主的程序(CPU密集型程序),多线程跑的时候,可以充分利用起所有的 CPU 核心数,比如说 8 个核心的CPU ,开8
个线程的时候,可以同时跑 8 个线程的运算任务,此时是最大效率。但是如果线程远远超出 CPU
核心数量,反而会使得任务效率下降,因为频繁的切换线程也是要消耗时间的。因此对于 CPU 密集型的任务来说,线程数等于 CPU 数是最好的了。02:如果是一个磁盘或网络为主的程序(IO密集型程序),一个线程处在 IO 等待的时候,另一个线程还可以在 CPU 里面跑,有时候
CPU 闲着没事干,所有的线程都在等着 IO,这时候他们就是同时的了,而单线程的话此时还是在一个一个等待的。我们都知道 IO 的速度比起
CPU 来是很慢的。此时线程数等于CPU核心数的两倍是最佳的。
java.util.function 函数式接口
4大函数式接口
- Function<T,R> 函数型接口 特点:传入T 有一个返回R
/*Function<String,Integer> function=new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return 1024;
}
};*/
//新写法 lambda 表达式写法
// Function<String,Integer> function=(s) -> {return 1024;};
//一个参数可以省略() 返回可以省略{return }
Function<String,Integer> function=s -> 1024;
System.out.println(function.apply("a"));
- Predicate 断定型接口 特点:返回boolean
/*Predicate<String> predicate=new Predicate<String>() {
@Override
public boolean test(String s) {
return false;
}
};*/
//lambda 表达式
// Predicate<String> predicate=s -> s.isEmpty();
//lambada 表达式+方法的引用
Predicate<String> predicate=String::isEmpty;
System.out.println(predicate.test("qcb"));
- Consumer 消费型接口 特点:没有返回值 有参数
/*Consumer<String> consumer=new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};*/
//lambda 表达式
// Consumer consumer= s -> System.out.println(s);
Consumer consumer= System.out::print;
consumer.accept("a");
- Supplier 宫给型接口 特点:无参数 有返回值
/*Supplier<String> supplier=new Supplier<String>() {
@Override
public String get() {
return "aa";
}
};*/
//lambda 表达式
// Supplier<String> supplier=() -> {return "aa";};
Supplier<String> supplier=() -> "aa";
System.out.println(supplier.get());
java.util.stream
流(Stream) 到底是什么呢?
是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。“集合讲的是数据,流讲的是计算!”
特点:
- Stream 自己不会存储元素
- Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。
- Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
阶段:
- 创建一个Stream:一个数据源(数组、集合)
- 中间操作:一个中间操作,处理数据源数据
- 终止操作:一个终止操作,执行中间操作链,产生结果
//题目:请按照给出数据,找出同时满足 *
//偶数ID且年龄大于24且用户名转为大写且用户名字母倒排序 *
// 最后只输出一个用户名字
User u1 = new User(11, "a", 23);
User u2 = new User(12, "b", 24);
User u3 = new User(13, "c", 22);
User u4 = new User(14, "d", 28);
User u5 = new User(16, "e", 26);
List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
list.stream().filter(user -> {
return user.getId() % 2 == 0 && user.getAge() > 24; //id偶数 并且 大于24的
})./*filter(user -> {
return user.getAge() > 24;
//Function<T,R> mapper)
}).*/map(user -> {
return user.getUserName().toUpperCase(); //把名称转为大写
}).sorted(/*(user1, user2) -> {
return user2.compareTo(user1); //倒叙
}*/Collections.reverseOrder()).limit(1).forEach(System.out::println);//只查一条
ForkJoinPool 分支合并框架
原理:Fork:把一个复杂任务进行分拆,大事化小Join:把分拆任务的结果进行合并
ForkJoinPool:分支合并池 类比=> 线程池
ForkJoinTask:ForkJoinTask 类比=> FutureTask
RecursiveTask:递归任务:继承后可以实现递归(自己调自己)调用的任务
@Override
protected Integer compute() {
if((end-begin)<=ADJUST_VALUE){
for (int i = begin; i <= end; i++) {
result=result+i;
}
}else {
int middle = (end + begin) / 2;
MyTask myTask1=new MyTask(begin,middle); //分支1
MyTask myTask2=new MyTask(middle+1,end);//分支2
myTask1.fork();//开启分支1
myTask2.fork();//开启分支2
result=myTask1.join()+myTask2.join();//合并
}
return result;
}
package com.bin.concurrent;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
//RecursiveTask 继承ForkJoinTask 继承 Future 可以调用callable接口 返回计算结果
class MyTask extends RecursiveTask<Integer> {
private static final Integer ADJUST_VALUE=10;
private int begin;
private int end;
private int result;
public MyTask(Integer begin, Integer end) {
this.begin = begin;
this.end = end;
}
@Override
protected Integer compute() {
if((end-begin)<=ADJUST_VALUE){
for (int i = begin; i <= end; i++) {
result=result+i;
}
}else {
int middle = (end + begin) / 2;
MyTask myTask1=new MyTask(begin,middle);
MyTask myTask2=new MyTask(middle+1,end);
myTask1.fork();
myTask2.fork();
result=myTask1.join()+myTask2.join();
}
return result;
}
}
/**
* 分支合并框架
* @Author: 邱成兵
* @Date: Created in 18:04 2021/5/8
*/
public class ForkJoinPollDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyTask myTask=new MyTask(0,100);
ForkJoinPool forkJoinPool=new ForkJoinPool();
ForkJoinTask<Integer> submit = forkJoinPool.submit(myTask);
System.out.println(submit.get());
forkJoinPool.shutdown();
}
}
CompletableFutrue - 异步调用
package com.bin.concurrent;
import java.util.concurrent.CompletableFuture;
/**
* 异步调用
*
* @Author: 邱成兵
* @Date: Created in 14:37 2021/5/11
*/
public class CompletableFutureDemo {
public static void main(String[] args) throws Exception {
/*CompletableFuture<Void> completableFuture= CompletableFuture.runAsync(new Runnable() {
@Override
public void run() {
System.out.println("a");
}
});*/
//执行异步调用没有返回参数的
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
System.out.println("没有返回值cccccc");
});
completableFuture.get();
/*CompletableFuture<Integer> completableFuture1=CompletableFuture.supplyAsync(new Supplier<Integer>() {
@Override
public Integer get() {
return 1024;
}
});*/
//执行异步调用有返回参数的
CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
// int a=1024/0;
return 1024;
});
System.out.println(completableFuture1.whenComplete((t, d) -> {
System.out.println("t:" + t);
System.out.println("d:" + d);
}).exceptionally(f -> {
System.out.println(f.getMessage());
return 4444;
}).get());
}
}
原理:https://blog.csdn.net/finalheart/article/details/87615546