JUC（java.util.concurrent）

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量50 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sorce201/article/details/132672864
版权

JUC（java.util.concurrent）

简介

用于处理线程的工具包，JDK1.5出现

进程和线程

进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。

线程（thread） 是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

总结来说:

进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程是资源分配的最小单位。

线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程是程序执行的最小单位。

线程状态

线程有六个状态：

NEW（新建）：当线程被创建出来还没有被调用start()时候的状态

RUNNABLE（准备就绪）：当线程被调用了start()，且处于等待操作系统分配资源（如CPU）、等待IO连接、正在运行状态，即表示Running状态和Ready状态。（注：不一定被调用了start()立刻会改变状态，还有一些准备工作，这个时候的状态是不确定的。）

BLOCKED（阻塞）：等待监视锁，这个时候线程被操作系统挂起。当进入synchronized块/方法或者在调用wait()被唤醒/超时之后重新进入synchronized块/方法，锁被其它线程占有，这个时候被操作系统挂起，状态为阻塞状态。 阻塞状态的线程，即使调用interrupt()方法也不会改变其状态。

WAITING（不见不散）：无条件等待，当线程调用wait()/join()/LockSupport.park()不加超时时间的方法之后所处的状态，如果没有被唤醒或等待的线程没有结束，那么将一直等待，当前状态的线程不会被分配CPU资源和持有锁。

TIMED_WAITING（过时不候）：有条件的等待，当线程调用sleep(睡眠时间)/wait(等待时间)/join(等待时间)/ LockSupport.parkNanos(等待时间)/LockSupport.parkUntil(等待时间)方法之后所处的状态，在指定的时间没有被唤醒或者等待线程没有结束，会被系统自动唤醒，正常退出。

TERMINATED(终结) ：执行完了run()方法。其实这只是Java语言级别的一种状态，在操作系统内部可能已经注销了相应的线程，或者将它复用给其他需要使用线程的请求，而在Java语言级别只是通过Java代码看到的线程状态而已。

img

wait/sleep的区别

（1）sleep 是 Thread 的静态方法，wait 是 Object 的方法，任何对象实例都能调用。

（2）sleep 不会释放锁，它也不需要占用锁。wait 会释放锁，但调用它的前提是当前线程占有锁(即代码要在 synchronized 中)。

（3）它们都可以被 interrupted 方法中断。

管程

管程(monitor)是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现).但是这样并不能保证进程以设计的顺序执行。

JVM 中同步是基于进入和退出管程(monitor)对象实现的，每个对象都会有一个管程(monitor)对象，管程(monitor)会随着 java 对象一同创建和销毁。

执行线程首先要持有管程对象，然后才能执行方法，当方法完成之后会释放管程，方法在执行时候会持有管程，其他线程无法再获取同一个管程。

用户线程和守护线程

用户线程:平时用到的普通线程,自定义线程

守护线程:运行在后台,是一种特殊的线程,比如垃圾回收

当主线程结束后,用户线程还在运行,JVM存活。

如果没有用户线程,都是守护线程,JVM结束。

Lock接口

Synchronized

synchronized 是 Java 中的关键字，是一种同步锁。它修饰的对象有以下几种：

  1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

  2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

    • 虽然可以使用 synchronized 来定义方法，但 synchronized 并不属于方法定义的一部分，因此，synchronized 关键字不能被继承。如果在父类中的某个方法使用了 synchronized 关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized 关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。

  3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

  4. 修改一个类，其作用的范围是 synchronized 后面括号括起来的部分，作用的对象是这个类的所有对象。

Lock

Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能。

方法介绍

（1）lock()：获取锁

使用lock()方法获取锁。如果锁已被其他线程获取，则进行等待。采用 Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用 Lock 必须在 try{}catch{}块中进行，并且将释放锁的操作放在finally 块中进行，以保证锁一定被被释放，防止死锁的发生。

Lock lock = ...;
lock.lock();
try{
	//处理任务
}catch(Exception ex){
    // 异常处理
}finally{
    //释放锁
	lock.unlock(); 
}

（2）newCondition：实现等待/通知模式

关键字 synchronized 与 wait()/notify()这两个方法一起使用可以实现等待/通知模式， Lock 锁的 newContition()方法返回 Condition 对象，Condition 类也可以实现等待/通知模式。用 notify()通知时，JVM 会随机唤醒某个等待的线程， 使用 Condition 类可以进行选择性通知， Condition 比较常用的两个方法：

**await()**会使当前线程等待,同时会释放锁,当其他线程调用 signal()时,线程会重新获得锁并继续执行。

**signal()**用于唤醒一个等待的线程。

注意：在调用 Condition 的 await()/signal()方法前，也需要线程持有相关的 Lock 锁，调用 await()后线程会释放这个锁，在 singal()调用后会从当前Condition 对象的等待队列中，唤醒 一个线程，唤醒的线程尝试获得锁， 一旦获得锁成功就继续执行。

（3）ReentrantLock：可重入锁

ReentrantLock 是唯一实现了 Lock 接口的类，并且 ReentrantLock 提供了更多的方法。

（4）ReadWriteLock：读写锁，主要应用在多读的资源，可提高效率

ReadWriteLock 也是一个接口，在它里面只定义了两个方法

  • Lock readLock()：获取读锁。
  • Lock writeLock()：获取写锁。

将文件的读写操作分开，分成 2 个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock 实现了 ReadWriteLock 接口。ReentrantReadWriteLock 里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和 writeLock()用来获取读锁和写锁

规则：

如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

Lock 和 synchronized 有以下几点不同：
  • Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言实现；
  • synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁；
  • Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用synchronized 时，等待的线程会一直等待下去，不能够响应中断；
  • 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。
  • Lock 可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时 Lock 的性能要远远优于synchronized。

线程间通信

线程间通信的模型有两种：共享内存和消息传递。

（1）可通过synchronized 搭配wait和notifyAll();来实现通信

（2）lock 和 newCondition、condition.await()以及condition.signalAll()搭配实现

集合的线程安全

多个线程对同一个集合进行读写操作会触发java.util.ConcurrentModificationException异常。

List线程安全

（1）Vector （较老，不太使用）

Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。

Vector线程安全的原理是它的add方法加上了synchronized 修饰。

（2）Collections （也不经常使用）

Collections提供了方法 synchronizedList 保证 list 是同步线程安全的

（3）CopyOnWriteArrayList（重点）

实现思路：

当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。

这时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来得及写会内存，其他的线程就会读到了脏数据。

特点：

  • 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。

  • 它是线程安全的。

  • 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。

  • 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。

  • 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

  • 独占锁效率低：采用读写分离思想解决

  • 写线程获取到锁，其他写线程阻塞

  • 复制思想

实现思路深化：

从“动态数组”和“线程安全”两个方面进一步对CopyOnWriteArrayList 的原理进行说明。

动态数组机制

它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因

由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList 效率很低；但是单单只是进行遍历查找的话，效率比较高。

线程安全机制

通过 volatile 和互斥锁来实现的。

通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证。

通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥锁”，就达到了保护数据的目的。

synchronized的作用范围

对于普通同步方法，锁是当前实例对象this。

对于静态同步方法，锁是当前类的 Class 对象。

对于同步方法块，锁是 Synchonized 括号里配置的对象

死锁

在这里插入图片描述

在这里插入图片描述

​

创建线程的方法

  • 通过创建Thread类
  • 通过Runable创建
  • 通过callable和future创建

Callable和Future接口

Callable接口

特点：

  • 为了实现 Runnable，需要实现不返回任何内容的 run（）方法，而对于Callable，需要实现在完成时返回结果的 call（）方法。
  • call（）方法可以引发异常，而 run（）则不能。
  • 为实现 Callable 而必须重写 call 方法
  • 不能直接替换 runnable,因为 Thread 类的构造方法根本没有 Callable

Future接口

将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable 返回）。Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写 5 种方法，这里列出了重要的方法,如下:

  1. **public boolean cancel（boolean mayInterrupt）：**用于停止任务。

    如果尚未启动，它将停止任务。如果已启动，则仅在 mayInterrupt 为 true时才会中断任务。

  2. **public Object get（）抛出 InterruptedException，ExecutionException：**用于获取任务的结果。

    如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。

  3. **public boolean isDone（）：**如果任务完成，则返回 true，否则返回 false

    可以看到 Callable 和 Future 做两件事-Callable 与 Runnable 类似，因为它封装了要在另一个线程上运行的任务，而 Future 用于存储从另一个线程获得的结果。实际上，future 也可以与 Runnable 一起使用。要创建线程，需要 Runnable。为了获得结果，需要 future。

FutureTask

Java 库具有具体的 FutureTask 类型，该类型实现 Runnable 和 Future，并方便地将两种功能组合在一起。 可以通过为其构造函数提供 Callable 来创建FutureTask。然后，将 FutureTask 对象提供给 Thread 的构造函数以创建Thread 对象。因此，间接地使用 Callable 创建线程

核心原理:(重点)

  • 在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成
  • 当主线程将来需要时，就可以通过 Future 对象获得后台作业的计算结果或者执行状态
  • 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。
  • 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法
  • 一旦计算完成，就不能再重新开始或取消计算
  • get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常
  • get 只计算一次,因此 get 方法放到最后

小结(重点)

  • 在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成, 当主线程将来需要时，就可以通过 Future对象获得后台作业的计算结果或者执行状态
  • 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果
  • 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。
  • 只计算一次

JUC三大辅助类

JUC 中提供了三种常用的辅助类，通过这些辅助类可以很好的解决线程数量过多时 Lock 锁的频繁操作。这三种辅助类为：

  • CountDownLatch: 减少计数
  • CyclicBarrier: 循环栅栏
  • Semaphore: 信号灯

减少计数 CountDownLatch

CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减 1 的操作，使用 await 方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。

CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这些线程会阻塞

其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程不会阻塞)

当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行

应用思考：

主要控制不同批线程需要上一批线程完成后才开始进行下一批线程。

示例：

package com.yw.mongocopy.juc;

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

//演示 CountDownLatch
public class CountDownLatchDemo {
    //6个同学陆续离开教室之后，班长锁门
    public static void main(String[] args) throws InterruptedException {

        //创建CountDownLatch对象，设置初始值
        CountDownLatch countDownLatch = new CountDownLatch(6);
        DemoFun demoFun = new DemoFun();

        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                demoFun.firstPlayer(countDownLatch);
            },String.valueOf(i)).start();
        }
        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                demoFun.secondPlayer(countDownLatch);
            },String.valueOf(i)).start();
        }

    }
}
class DemoFun{
	
    public void firstPlayer(CountDownLatch countDownLatch){
        try {
            TimeUnit.SECONDS.sleep(new Random().nextInt(5));
        }catch (Exception e){

        }
        System.out.println("第一批"+Thread.currentThread().getName()+" 号选手到达");
        //计数  -1
        countDownLatch.countDown();
    }
    public void secondPlayer(CountDownLatch countDownLatch){
        try{
            // 阻塞等待
            countDownLatch.await();
            System.out.println("第二批"+Thread.currentThread().getName()+" 号选手出发");
        }catch (Exception e){

        }
    }
}

循环栅栏 CyclicBarrier

CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作

应用思考

应用于同一批线程相互等待，等这一批线程都完成了某一阶段后，可触发另一线程启动，并接着做下一阶段的事情

示例：

package com.yw.mongocopy.juc;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

//集齐7颗龙珠就可以召唤神龙
public class CyclicBarrierDemo {

    //创建固定值
    private static final int NUMBER = 7;

    public static void main(String[] args) {
        //创建CyclicBarrier
        CyclicBarrier cyclicBarrier =
                new CyclicBarrier(NUMBER,()->{
                    System.out.println("*****集齐7颗龙珠就可以召唤神龙");
                });
        MyClass myClass= new MyClass();
        //集齐七颗龙珠过程
        for (int i = 1; i <=7; i++) {
            new Thread(()->{
                myClass.shouji(cyclicBarrier);
            },String.valueOf(i)).start();
        }
    }
}
class MyClass{
    public void shouji(CyclicBarrier cyclicBarrier){
        try {
            System.out.println(Thread.currentThread().getName()+" 星龙被收集到了");
            //等待
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName()+" 星龙完成");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

信号灯 Semaphore

Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方法获得许可证，release 方法释放许可

应用思考：

主要应用于对有限资源的管理，当资源不足时，则进行等待。有资源则进行操作

示例：

package com.yw.mongocopy.juc;

import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

//6辆汽车，停3个车位
public class SemaphoreDemo {
    public static void main(String[] args) {
        //创建Semaphore，设置许可数量
        Semaphore semaphore = new Semaphore(3);
        //模拟6辆汽车
        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                try {
                    //抢占
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+" 抢到了车位");
                    //设置随机停车时间
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName()+" ------离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //释放
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

读写锁

介绍

读写锁包含两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁

  1. 线程进入读锁的前提条件：

    没有其他线程的写锁

    没有写请求, 或者有写请求，但调用线程和持有锁的线程是同一个(可重入锁)。

  2. 线程进入写锁的前提条件：

    没有其他线程的读锁

    没有其他线程的写锁

特性：

（1）公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。

（2）重进入：读锁和写锁都支持线程重进入。

（3）锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁。

重点：

在线程持有读锁的情况下，该线程不能取得写锁（因为获取写锁的时候，如果发现当前的读锁被占用，就马上获取失败，不管读锁是不是被当前线程持有）。

在线程持有写锁的情况下，该线程可以继续获取读锁（获取读锁时如果发现写锁被占用，只有写锁没有被当前线程占用的情况才会获取失败）。

原因: 当线程获取读锁的时候，可能有其他线程同时也在持有读锁，因此不能把获取读锁的线程“升级”为写锁；而对于获得写锁的线程，它一定独占了读写锁，因此可以继续让它获取读锁，当它同时获取了写锁和读锁后，还可以先释放写锁继续持有读锁，这样一个写锁就“降级”为了读锁。

阻塞队列

介绍：

阻塞队列，顾名思义，首先它是一个队列, 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出；

在这里插入图片描述

当队列是空的，从队列中获取元素的操作将会被阻塞

当队列是满的，从队列中添加元素的操作将会被阻塞

试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素

试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增

核心方法

在这里插入图片描述

1.放入数据

  • （1）offer(anObject):表示如果可能的话,将 anObject 加到 BlockingQueue 里,即如果 BlockingQueue 可以容纳,则返回 true,否则返回 false.（本方法不阻塞当前执行方法的线程）
  • （2）offer(E o, long timeout, TimeUnit unit)：可以设定等待的时间，如果在指定的时间内，还不能往队列中加入 BlockingQueue，则返回失败
  • （3）put(anObject):把 anObject 加到 BlockingQueue 里,如果 BlockQueue 没有空间,则调用此方法的线程被阻断直到 BlockingQueue 里面有空间再继续.

2.获取数据

  • poll(time): 取走 BlockingQueue 里排在首位的对象,若不能立即取出,则可以等time 参数规定的时间,取不到时返回 null
  • poll(long timeout, TimeUnit unit)：从 BlockingQueue 取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据。否则知道时间超时还没有数据可取，返回失败。
  • take(): 取走 BlockingQueue 里排在首位的对象,若 BlockingQueue 为空,阻断进入等待状态直到 BlockingQueue 有新的数据被加入
  • drainTo(): 一次性从 BlockingQueue 获取所有可用的数据对象（还可以指定获取数据的个数），通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁。

ArrayBlockingQueue（常用）：由数组结构组成的有界阻塞队列

基于数组的阻塞队列实现，在 ArrayBlockingQueue 内部，维护了一个定长数组，以便缓存队列中的数据对象，这是一个常用的阻塞队列，除了一个定长数组外，ArrayBlockingQueue 内部还保存着两个整形变量，分别标识着队列的头部和尾部在数组中的位置。

ArrayBlockingQueue 放入消息和获取消息共用同一个锁对象，因此于两者无法真正并行运行，这与LinkedBlockingQueue不同。（原因Doug Lea认为ArrayBlockingQueue 的读取和写入都足够轻巧，引入独立锁机制，给代码带来额外的复杂性，对性能也没有好处 ）

ArrayBlockingQueue 和LinkedBlockingQueue 间还有一个明显的不同之处在于，前者在插入或删除元素时不会产生或销毁任何额外的对象实例，而后者则会生成一个额外的Node 对象。这在长时间内需要高效并发地处理大批量数据的系统中，其对于GC 的影响还是存在一定的区别。

而在创建 ArrayBlockingQueue 时，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁。

LinkedBlockingQueue(常用)：由链表结构组成的有界阻塞队列。

大小默认值为integer.MAX_VALUE

LinkedBlockingQueue 能够高效的处理并发数据，对生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能

ArrayBlockingQueue 和 LinkedBlockingQueue 是两个最普通也是最常用的阻塞队列，一般情况下，在处理多线程间的生产者消费者问题，使用这两个类足以。

DelayQueue：使用优先级队列实现的延迟无界阻塞队列。

DelayQueue 中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue 是一个没有大小限制的队列，因此往队列中插入数据的操作（生产者）永远不会被阻塞，而只有获取数据的操作（消费者）才会被阻塞。

PriorityBlockingQueue：支持优先级排序的无界阻塞队列。

基于优先级的阻塞队列（优先级的判断通过构造函数传入的 Compator 对象来决定），但需要注意的是 PriorityBlockingQueue 并不会阻塞数据生产者，而只会在没有可消费的数据时，阻塞数据的消费者。

因此使用的时候要特别注意，生产者生产数据的速度绝对不能快于消费者消费数据的速度，否则时间一长，会最终耗尽所有的可用堆内存空间。

在实现 PriorityBlockingQueue 时，内部控制线程同步的锁采用的是公平锁。

SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列。

一种无缓冲的等待队列，类似于无中介的直接交易，生产者和消费者必须同时都在，不然就阻塞。好处在于单个产品的及时响应性能可能会降低。

声明一个 SynchronousQueue 有两种不同的方式，它们之间有着不太一样的行为。

公平模式和非公平模式的区别:

公平模式：SynchronousQueue 会采用公平锁，并配合一个 FIFO 队列来阻塞多余的生产者和消费者，从而体系整体的公平策略；

非公平模式（SynchronousQueue 默认）：SynchronousQueue 采用非公平锁，同时配合一个 LIFO 队列来管理多余的生产者和消费者，而后一种模式，如果生产者和消费者的处理速度有差距，则很容易出现饥渴的情况，即可能有某些生产者或者是消费者的数据永远都得不到处理。

LinkedTransferQueue：由链表组成的无界阻塞队列。

LinkedTransferQueue 是一个由链表结构组成的无界阻塞 TransferQueue 队列。相对于其他阻塞队列，LinkedTransferQueue 多了 tryTransfer 和transfer 方法。

LinkedTransferQueue 采用一种预占模式。意思就是消费者线程取元素时，如果队列不为空，则直接取走数据，若队列为空，那就生成一个节点（节点元素为 null）入队，然后消费者线程被等待在这个节点上，后面生产者线程入队时发现有一个元素为 null 的节点，生产者线程就不入队了，直接就将元素填充到该节点，并唤醒该节点等待的线程，被唤醒的消费者线程取走元素，从调用的方法返回。

LinkedBlockingDeque：由链表组成的双向阻塞队列

LinkedBlockingDeque 是一个由链表结构组成的双向阻塞队列，即可以从队列的两端插入和移除元素。对于一些指定的操作，在插入或者获取队列元素时如果队列状态不允许该操作可能会阻塞住该线程直到队列状态变更为允许操作，这里的阻塞一般有两种情况

插入元素时: 如果当前队列已满将会进入阻塞状态，一直等到队列有空的位置时再讲该元素插入，该操作可以通过设置超时参数，超时后返回 false 表示操作失败，也可以不设置超时参数一直阻塞，中断后抛出 InterruptedException 异常

读取元素时: 如果当前队列为空会阻塞住直到队列不为空然后返回元素，同样可以通过设置超时参数

线程池

简介

优势：

线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。

线程池不仅能够保证内核的充分利用，还能防止过分调度

特点：

  • 降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
  • 提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。
  • 提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

Java 中的线程池是通过 Executor 框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor这几个类

在这里插入图片描述

常用参数（重点）

  1. corePoolSize 线程池的核心线程数
  2. maximumPoolSize 能容纳的最大线程数
  3. keepAliveTime 空闲线程存活时间
  4. unit 存活的时间单位
  5. workQueue 存放提交但未执行任务的队列
  6. threadFactory 创建线程的工厂类
  7. handler 等待队列满后的拒绝策略

线程池中，有三个重要的参数，决定影响了拒绝策略：corePoolSize - 核心线程数，也即最小的线程数。workQueue - 阻塞队列 。 maximumPoolSize -最大线程数

当提交任务数大于 corePoolSize 的时候，会优先将任务放到 workQueue 阻塞队列中。当阻塞队列饱和后，会扩充线程池中线程数，直到达到maximumPoolSize 最大线程数配置。此时，再多余的任务，则会触发线程池的拒绝策略了。

总结起来，也就是一句话，当提交的任务数大于（workQueue.size() +maximumPoolSize ），就会触发线程池的拒绝策略。

拒绝策略(重点)

CallerRunsPolicy: 当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大

AbortPolicy: 丢弃任务，并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。

DiscardPolicy: 直接丢弃，其他啥都没有

DiscardOldestPolicy: 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入

线程池的种类

newCachedThreadPool(常用)

作用：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程.

特点:

  • 线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）
  • 线程池中的线程可进行缓存重复利用和回收（回收默认时间为 1 分钟）
  • 当线程池中，没有可用线程，会重新创建一个线程

场景: 适用于创建一个可无限扩大的线程池，服务器负载压力较轻，执行时间较短，任务多的场景

创建：

public static ExecutorService newCachedThreadPool(){
    /**
    * corePoolSize 线程池的核心线程数
    * maximumPoolSize 能容纳的最大线程数
    * keepAliveTime 空闲线程存活时间
    * unit 存活的时间单位
    * workQueue 存放提交但未执行任务的队列
    * threadFactory 创建线程的工厂类:可以省略
    * handler 等待队列满后的拒绝策略:可以省略
    */
    return new ThreadPoolExecutor(0,
    Integer.MAX_VALUE,
    60L,
    TimeUnit.SECONDS,
    new SynchronousQueue<>(),
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy());
}

newFixedThreadPool(常用)

作用：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

特征：

  • 线程池中的线程处于一定的量，可以很好的控制线程的并发量
  • 线程可以重复被使用，在显示关闭之前，都将一直存在
  • 超出一定量的线程被提交时候需在队列中等待

场景: 适用于可以预测线程数量的业务中，或者服务器负载较重，对线程数有严格限制的场景

创建：

public static ExecutorService newFixedThreadPool(){

    return new ThreadPoolExecutor(10,
    10,
    0L,
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(),
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy());
}

newSingleThreadExecutor(常用)

作用：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的newFixedThreadPool 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

场景: 适用于需要保证顺序执行各个任务，并且在任意时间点，不会同时有多个线程的场景

特征： 线程池中最多执行 1 个线程，之后提交的线程活动将会排在队列中以此执行

public static ExecutorService newSingleThreadExecutor(){

    return new ThreadPoolExecutor(1, 1,0L,
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(),
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy());
}

newScheduleThreadPool(了解)

作用: 线程池支持定时以及周期性执行任务，创建一个 corePoolSize 为传入参数，最大线程数为整形的最大数的线程池**

特征:

（1）线程池中具有指定数量的线程，即便是空线程也将保留

（2）可定时或者延迟执行线程活动

场景: 适用于需要多个后台线程执行周期任务的场景

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {

    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}

newWorkStealingPool

jdk1.8 提供的线程池，底层使用的是 ForkJoinPool 实现，创建一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用 cpu 核数的线程来并行执行任务

场景: 适用于大耗时，可并行执行的场景

public static ExecutorService newWorkStealingPool(int parallelism) {
    /**
    * parallelism：并行级别，通常默认为 JVM 可用的处理器个数
    * factory：用于创建 ForkJoinPool 中使用的线程。
    * handler：用于处理工作线程未处理的异常，默认为 null
    * asyncMode：用于控制 WorkQueue 的工作模式:队列---反队列
    */
    return new ForkJoinPool(parallelism,
    ForkJoinPool.defaultForkJoinWorkerThreadFactory, null,
    true);
}

总结

步骤：

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

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

  • 2.1：如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
  • 2.2：如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
  • 2.3：如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
  • 2.4 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。

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

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

  • 4.1：如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。
  • 4.2：所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

注意事项：

一般不使用给定的线程池进行创建，而是由自己设定参数来创建线程池。

在这里插入图片描述

sorce201
关注
专栏目录
java.util.concurrent 测试源文件
02-14
Java.util.concurrent（JUC）是Java平台中的一个核心包，专门用于处理多线程并发问题。这个包包含了大量的工具类和接口，极大地简化了并发编程的复杂性，提高了程序的性能和可伸缩性。本测试源文件主要是针对JUC并发...
让多个线程等待就绪之后一起执行
uncle_king的博客
01-29 2396
田径运动员在赛道上准备就绪，只等哨声一响就起跑，如果用多线程模拟这种情形呢？我们可以定义10个线程，然后我们用CyclicBarrier来让这10个启动的线程进入等待就绪的状态，一旦这10个线程准备就绪，就可以让这10个线程跑起来。 import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.
The java.util.concurrent synchronizer framework.pdf
01-02
文档标题“java.util.concurrent同步器框架”和描述“Doug Lea的java.util.concurrent同步器框架”表明本文将探讨由Doug Lea所撰写的关于Java并发编程中同步器框架的内容。文档中提到了AbstractQueuedSynchronizer类...
juconcurrent:java.util.concurrent
05-02
Java JUC的使用1.volatile关键字-内存可见性2.原子变量-CAS算法3.ConcurrentHashMap锁分段机制4.CountDownLatch闭锁5.实现Callable接口6.Lock同步锁7.Condition控制线程通信8.线程按序交替9.ReadWriteLock读写锁10....
Java_JUC_Study:java.util.concurrent代码示例学习
03-09
Java并发编程是Java开发中的重要领域，特别是在多线程应用中，`java.util.concurrent`（JUC）包提供了丰富的工具类和接口，帮助开发者高效、安全地管理并发任务。本项目"Java_JUC_Study"显然是一个针对这个关键包的...
JUC-High-Concurrency:java.util.concurrent JUC高并发处理
04-03
Java.util.concurrent（JUC）是Java平台中处理高并发的核心工具包，它为开发者提供了丰富的并发组件和机制，使得在多线程环境下的编程变得更加高效和安全。本篇将深入探讨JUC中的重要知识点，包括同步、可重入锁、类...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 117
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
刷题---顺序表算法题
weixin_63997543的博客
11-11 275
顺序算法题----力扣刷题
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 286
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
JAVA-01-变量
LJH_laura_li的博客
11-08 470
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 296
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
shangan_3的博客
11-08 212
【代码】JAVA学习接口案例实例。
Spring资源加载模块，原来XML就这，活该被注解踩在脚下 手写Spring第六篇了
mkii_hong的博客
11-11 665
Spring通过【资源】和【资源加载】帮我们找到这些配置文件然后通过大厨解析配置最后把"菜"（Bean）放到"厨房"（容器）里本文由 https://github.com/hongweihao/small-spring/tree/6_resource_load 赞注完成本文完 | 求赞求关注求转发!
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1141
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 687
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 343
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
SpringMVC
hi_zf的博客
11-11 158
处理器映射器: HandlerMapping。处理器适配器: HandlerAdapter。视图解析器: ViewResolver。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1017
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
greendao使用封装
白高林的专栏
11-07 454
greenDAO
Java并发工具包java.util.concurrent深度解析
"JUC并发包开发手册详细介绍了Java并发工具包java.util.concurrent，包括 BlockingQueue 接口的使用和其在并发编程中的重要性。本文档基于Jakob Jenkov的博客翻译，适用于Java 6，尽管部分可能与Java 5有所不同。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值