Day128.JUC：阻塞队列(BlokingQueue)、线程池(ThreadPoolExecutor)、JMM(Java内存模型)

焰火青年·

已于 2022-08-16 23:37:31 修改

阅读量379

点赞数

分类专栏： Java 文章标签： java JUC

于 2022-08-16 08:46:01 首次发布

本文链接：https://blog.csdn.net/a111042555/article/details/126358172

版权

Java 专栏收录该内容

39 篇文章 2 订阅

订阅专栏

一、阻塞队列(BlockingQueue)

二、线程池 ★★★

1、Excutors工具类

2、ThreadPoolExecutor 线程池核心类 ★★

一、阻塞队列(BlockingQueue)

在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤起

BlockingQueue即阻塞队列，是java.util.concurrent下的一个接口，BlockingQueue是为了解决多线程中数据高效安全传输而提出的。被阻塞的情况主要有如下两种：

当队列满了的时候进行入队列操作
当队列空了的时候进行出队列操作

阻塞队列主要用在生产者/消费者的场景：一个线程生产、一个线程消费

好处：不再需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，减少了代码量，提高了效率，保证了线程安全

BlockingQueue接口主要有以下7个实现类：

ArrayBlockingQueue: 由数组结构组成的有界阻塞队列。
LinkedBlockingQueue: 由链表结构组成的有界（但大小默认值为integer.MAX_VALUE）阻塞队列。
PriorityBlockingQueue: 支持优先级排序的无界阻塞队列。
DelayQueue: 使用优先级队列实现的延迟无界阻塞队列。
SynchronousQueue: 不存储元素的阻塞队列，也即单个元素的队列。
LinkedTransferQueue: 由链表组成的无界阻塞队列。
LinkedBlockingDeque: 由链表组成的双向阻塞队列。

它的方法可以分成以下4类：

	抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
检查	element()	peek()	不可用	不可用

抛出异常：

add正常执行返回true，element（不删除）和remove返回阻塞队列中的第一个元素当阻塞队列满时，再往队列里add插入元素会抛IllegalStateException:Queue full 当阻塞队列空时，再往队列里remove移除元素会抛NoSuchElementException 当阻塞队列空时，再调用element检查元素会抛出NoSuchElementException

特定值：

插入方法，成功ture失败false 移除方法，成功返回出队列的元素，队列里没有就返回null 检查方法，成功返回队列中的元素，没有返回null

一直阻塞：

如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行。当阻塞队列满时，再往队列里put元素，队列会一直阻塞生产者线程直到put数据or响应中断退出当阻塞队列空时，再从队列里take元素，队列会一直阻塞消费者线程直到队列可用

超时退出：

如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行，但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)。

public class BlockingQueueDemo {
    public static void main(String[] args) {
        //List<String> list = new ArrayList<>();
        //长度为3的 有界的 数组结构的队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

        //第一组:抛异常
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        //System.out.println(blockingQueue.add("d")); //IllegalStateException: Queue full
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        //System.out.println(blockingQueue.remove()); //NoSuchElementException

        //第二组:特殊值
        System.out.println(blockingQueue.offer("a")); //true
        System.out.println(blockingQueue.offer("b")); //true
        System.out.println(blockingQueue.offer("c")); //true
        System.out.println(blockingQueue.offer("d")); //false

        System.out.println(blockingQueue.poll()); //a
        System.out.println(blockingQueue.poll()); //b
        System.out.println(blockingQueue.poll()); //c
        System.out.println(blockingQueue.poll()); //null

        //第三组:阻塞
        try {
            blockingQueue.put("a");
            blockingQueue.put("b");
            blockingQueue.put("c");
            //blockingQueue.put("d");
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            //System.out.println(blockingQueue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //第四组:超时
        try {
            System.out.println(blockingQueue.offer("a", 3, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("b", 3, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("c", 3, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("d", 3, TimeUnit.SECONDS)); //false

            System.out.println(blockingQueue.poll(3,TimeUnit.SECONDS));
            System.out.println(blockingQueue.poll(3,TimeUnit.SECONDS));
            System.out.println(blockingQueue.poll(3,TimeUnit.SECONDS));
            System.out.println(blockingQueue.poll(3,TimeUnit.SECONDS)); //null
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

二、线程池 ★★★

例子： 10年前单核CPU电脑，假的多线程，CPU需要来回切换线程。现在是多核电脑，多个线程各自跑在独立的CPU上，效率高。

线程池的优势：线程复用；控制最大并发数；管理线程。提前创建好线程，合理控制连接数

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的销耗。

提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。

提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

ThreadPoolExecutor：线程池核心类； Excutors：线程池工具类

1、Excutors工具类

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //一池一线程 银行网点有一个办事窗口
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();
        //一池N线程 银行网点有三个办事窗口
        //ExecutorService threadPool = Executors.newFixedThreadPool(3);
        //可扩展线程池 根据业务类扩展线程数据
        ExecutorService threadPool = Executors.newCachedThreadPool();
        try {
            for (int i = 0; i < 30; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()
                            + "业务员处理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

Excutors 工具类方法底层

上述案例中的三个方法的本质都是 ThreadPoolExecutor，只是具体参数值不同。

2、ThreadPoolExecutor 线程池核心类 ★★

阿里开发规范

【强制】线程池不润允许使用Executors去创建，而是通过ThreadPoolExecutor的方式。

说明：Executors 返回的线程池的弊端如下：

1）FixedThreadPool、SingleThreadPool、CachedThreadPool、ScheduledThreadPool：
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。

ThreadPoolExecutor 7个重要参数

public ThreadPoolExecutor(int corePoolSize, //核心线程数(常备线程)
                          int maximumPoolSize, //最大线程数
                          long keepAliveTime, //多余空闲线程数的存活时间
                          TimeUnit unit, //存活时间单位
                          BlockingQueue<Runnable> workQueue, //任务队列 提交但未执行
                          ThreadFactory threadFactory, //线程工厂
                          RejectedExecutionHandler handler //拒绝策略
) {
    .....
}

自定义线程池

        ExecutorService threadPool =new ThreadPoolExecutor(
                2,
                5,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                //new ThreadPoolExecutor.AbortPolicy() //抛异常
                //new ThreadPoolExecutor.CallerRunsPolicy() //从哪来回哪去(主线程)
                new ThreadPoolExecutor.DiscardPolicy() //取消等待时间最长的
        );

corePoolSize：线程池中的常驻核心线程数
maximumPoolSize：线程池中能够容纳同时执行的最大线程数，此值必须大于等于1
keepAliveTime：多余的空闲线程的存活时间当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程为止
unit：keepAliveTime的单位
workQueue：任务队列，被提交但尚未被执行的任务
threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可
handler：拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时，如何来拒绝请求执行的runnable的策略

3、线程池底层原理 ★★

在创建了线程池后，线程池中的线程数为零。

当调用execute()方法添加一个请求任务时，线程池会做出如下判断：

如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；

如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；

如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；

如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。

当一个线程完成任务时，它会从队列中取下一个任务来执行。

当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断：

如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。

所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。

4、拒绝策略

一般我们创建线程池时，为防止资源被耗尽，任务队列都会选择创建有界任务队列，但这种模式下如果出现任务队列已满且线程池创建的线程数达到你设置的最大线程数时，这时就需要你指定ThreadPoolExecutor的RejectedExecutionHandler参数即合理的拒绝策略，来处理线程池"超载"的情况。

ThreadPoolExecutor自带的拒绝策略如下：

AbortPolicy (默认)：直接抛异常：RejectedExecutionException，阻止系统正常运行
CallerRunsPolicy：从哪来回哪去，将某些任务回退到调用者，从而降低新任务的流量。“调用者运行”一种调节机制
DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加人队列中尝试再次提交当前任务。(关注时效，如一分钟验证码)
DiscardPolicy：默默地丢弃无法处理的任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种策略。

以上内置的策略均实现了RejectedExecutionHandler接口，也可以自己扩展RejectedExecutionHandler接口，定义自己的拒绝策略

三、JMM Java内存模型

计算机运行架构

JMM即为JAVA 内存模型(java memory model)。

因为在不同的硬件生产商和不同的操作系统下，内存的访问逻辑有一定的差异，不同的系统会出现各种问题。Java内存模型，就是为了屏蔽系统和硬件的差异，让一套代码在不同平台下能到达相同的访问结果。Java能跨平台的原因:JAVA程序不是直接在平台上运行的,是在java虚机(JVM)上进行的

Java内存模型是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。JMM是围绕原子性，有序性、可见性展开。

此处的主内存和工作内存跟JVM内存划分（堆、栈、方法区）是在不同的维度上进行的，

JMM规定了内存主要划分为主内存和工作内存两种，主内存对应的是硬件的物理内存，工作内存对应的是寄存器和高速缓存。

JMM对共享内存的操作做出了如下两条规定：

线程对共享内存的所有操作都必须在自己的工作内存中进行，不能直接从主内存中读写；

不同线程无法直接访问其他线程工作内存中的变量，因此共享变量的值传递需要通过主内存完成。

内存模型的三大特性：原子性、可见性、有序性

原子性：即不可分割性。
1. 使用Lock 或 sychronized 来变成一个原子操作。
2. 使用 JUC 下的原子类：AtomicInteger、AtomicLong、AtomicReference等。

可见性：每个线程都有自己的工作内存，所以当某个线程修改完某个变量之后，在其他的线程中，未必能观察到该变量已经被修改。在 Java 中 volatile、synchronized 和 final 实现可见性。volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。

有序性：单线程是有序的，多线程是无序的。JMM的工作内存和主内存之间存在延迟，并且 java会对一些指令进行重新排序 (指令重排)。
1. volatile 关键字本身就包含了禁止指令重排序的语义
2. synchronized 则是由“一个变量在同一个时刻只允许一条线程对其进行lock操作”这条规则获得的，这个规则决定了持有同一个锁的两个同步块只能串行地进入

创建对象并非原子性操作：创建对象时，在JVM会经过三步：

（1）分配内存空间
（2）执行方法构造，初始化内存
（3）将对象指向分配好的这个空间

如果A线程创建对象的步骤为1、3、2，B线程在执行完1、3后进入，判定到LazyMan已不为空，return 获取到未初始化的LazyMan对象，则会造成空指针异常。

volatile关键字作用：

1、保证其有序性，指令执行的顺序与程序指明的顺序一致

2、保证其内存可见性，即每一时刻线程读取到该变量的值都是内存中最新的那个值，线程每次操作该变量都需要先读取该变量。

好文推荐：Java内存模型（JMM）与Volatile关键字底层原理

volatile

在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。

volatile关键字作用：

1、保证其有序性，指令执行的顺序与程序指明的顺序一致

2、保证其内存可见性，即每一时刻线程读取到该变量的值都是内存中最新的那个值，线程每次操作该变量都需要先读取该变量。

注意：无法保证原子性，synchronized 可以

1. 验证可见性

读写锁操作的共同资源Map，一定是volatile

public class VolatileDemo {

    private volatile static Integer flag = 1;

    public static void main(String[] args)  throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是子线程工作内存flag的值：" + flag);
                //当flag被volatile修饰时，main线程改了值，子线程可见
                while(flag == 1){
                }
                System.out.println("子线程操作结束..." + flag);
            }
        }).start();
        Thread.sleep(500);
        flag = 2;
        System.out.println("我是主线程工作内存flag的值：" + flag);
    }
}

没有volatile：
添加volatile：工作区间的值互通

2. 验证可用性

public class VolatileOrderDemo {
    static int a,b;
    static int x,y;
    
    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        while (true){
            i++;
            a = b = x = y = 0;
            Thread thread1 = new Thread(() -> {
                a = 1;
                x = b;
            }, "");	
            Thread thread2 = new Thread(() -> {
                b = 1;
                y = a;
            }, "");
            thread1.start();
            thread2.start();
            //加入线程，等待加入的线程终止后再继续执行当前线程。
            thread1.join();
            thread2.join();
            System.out.println("第" + i + "次打印：x=" + x + ", y=" + y);
            if (x == 0 && y == 0){
                break;
            }
        }
    }
}

如果出现[0, 0]，则说明进行了指令重排{因为JMM的工作内存和主内存之间存在延迟}。

解决指令重排：添加volatile关键字，让两个线程都能看到对方的变量。

3. 验证不具备原子性

class DataOne{
    private volatile Integer number = 0;
    //验证volatile不具备原子性，synchronized具备原子性
    public synchronized Integer incr(){
        return ++number;
    }
}

public class VolatileAtomicDemo {
    public static void main(String[] args) {
        DataOne dataOne = new DataOne();
        //1000个线程调用+1, 方法：正确结果应该是1000
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                System.out.println(dataOne.incr());
            }).start();
        }
    }
}

Happen-Before(了解)

Happen-Before：先行发生原则