抽象队列同步器AQS应用之阻塞队列BlockingQueue详解

最新推荐文章于 2023-03-07 17:59:23 发布
最新推荐文章于 2023-03-07 17:59:23 发布
阅读量290 收藏
点赞数
分类专栏： 并发编程 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yemuxiaweiliang/article/details/120967595
版权

系列文章目录

Java并发编程技术知识点梳理（第一篇）操作系统底层工作的整体认识
Java并发编程技术知识点梳理（第二篇）并发编程之JMM&volatile详解
Java并发编程技术知识点梳理（第三篇）CPU缓存一致性协议MESI
Java并发编程技术知识点梳理（第四篇）并发编程之synchronized详解
Java并发编程技术知识点梳理（第五篇）抽象队列同步器AQS应用Lock详解
Java并发编程技术知识点梳理（第六篇）并发编程之LockSupport的 park 方法及线程中断响应
Java并发编程技术知识点梳理（第七篇）抽象队列同步器AQS应用之阻塞队列BlockingQueue详解
Java并发编程技术知识点梳理（第八篇）并发编程之CountDownLatch&Semaphore原理与应用
Java并发编程技术知识点梳理（第九篇）并发编程之Atomic&Unsafe魔法类详解
Java并发编程技术知识点梳理（第十篇）Collections之HashMap分析
Java并发编程技术知识点梳理（第十一篇）并发编程之Executor线程池原理与源码解读
Java并发编程技术知识点梳理（第十二篇）并发编程之定时任务&定时线程池

抽象队列同步器AQS应用之阻塞队列BlockingQueue详解

概要

BlockingQueue，是java.util.concurrent 包提供的用于解决并发生产者 - 消费者问题的最有用的类，它的特性是在任意时刻只有一个线程可以进行take或者put操作，并且BlockingQueue提供了超时return null的机制，在许多生产场景里都可以看到这个工具的身影。

队列类型

无限队列 （unbounded queue ） - 几乎可以无限增长
有限队列 （ bounded queue ） - 定义了最大容量

队列数据结构

队列实质就是一种存储数据的结构

  • 通常用链表或者数组实现
  • 一般而言队列具备FIFO先进先出的特性，当然也有双端队列（Deque）优先级队列
  • 主要操作：入队（EnQueue）与出队（Dequeue）

在这里插入图片描述
常见的4种阻塞队列

  • ArrayBlockingQueue 由数组支持的有界队列
  • LinkedBlockingQueue 由链接节点支持的可选有界队列
  • PriorityBlockingQueue 由优先级堆支持的无界优先级队列
  • DelayQueue 由优先级堆支持的、基于时间的调度队列

ArrayBlockingQueue

队列基于数组实现,容量大小在创建ArrayBlockingQueue对象时已定义好
在这里插入图片描述
队列创建：

BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(10);

应用场景
在线程池中有比较多的应用，生产者消费者场景
工作原理
基于ReentrantLock保证线程安全，根据Condition实现队列满时的阻塞

LinkedBlockingQueue

是一个基于链表的无界队列(理论上有界)

BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>();

上面这段代码中，blockingQueue 的容量将设置为 Integer.MAX_VALUE 。
向无限队列添加元素的所有操作都将永远不会阻塞，因此它可以增长到非常大的容量。
使用无限 BlockingQueue 设计生产者 - 消费者模型时最重要的是 消费者应该能够像生产者向队列添加消息一样快地消费消息 。否则，内存可能会填满，然后就会得到一个 OutOfMemory 异常。

DelayQueue

由优先级堆支持的、基于时间的调度队列，内部基于无界队列PriorityQueue实现，而无界队列基于数组的扩容实现。

BlockingQueue<String> blockingQueue = new DelayQueue();

要求
入队的对象必须要实现Delayed接口,而Delayed集成自Comparable接口
应用场景
电影票
工作原理：
队列内部会根据时间优先级进行排序。延迟类线程池周期执行。

BlockingQueue API

BlockingQueue 接口的所有方法可以分为两大类：负责向队列添加元素的方法和检索这些元素的方法。在队列满/空的情况下，来自这两个组的每个方法的行为都不同。

添加元素

方法说明
add()如果插入成功则返回 true，否则抛出 IllegalStateException 异常
put()将指定的元素插入队列，如果队列满了，那么会阻塞直到有空间插入
offer()如果插入成功则返回 true，否则返回 false
offer(E e, long timeout, TimeUnit unit)尝试将元素插入队列，如果队列已满，那么会阻塞直到有空间插入

检索元素

方法说明
take()获取队列的头部元素并将其删除，如果队列为空，则阻塞并等待元素变为可用
poll(long timeout, TimeUnit unit)检索并删除队列的头部，如有必要，等待指定的等待时间以使元素可用，如果超时，则返回 null

多线程生产者-消费者示例

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

  • 解耦
  • 支持并发（concurrency）
  • 支持忙闲不均
package com.yg.edu.queue.test;

/**
 * @author 史凯强
 * @date 2021/10/27 13:31
 * @desc
 **/
public class Main {
    public static void main(String[] args) {
        Resource resource = new Resource();
        //生产者线程
        ProducerThread p1 = new ProducerThread(resource,"生产者1");
        ProducerThread p2 = new ProducerThread(resource,"生产者2");
        ProducerThread p3 = new ProducerThread(resource,"生产者3");
        ProducerThread p4 = new ProducerThread(resource,"生产者4");
        ProducerThread p5 = new ProducerThread(resource,"生产者5");
        //多个消费者
        ConsumerThread c1 = new ConsumerThread(resource,"消费者1");
        ConsumerThread c2 = new ConsumerThread(resource,"消费者2");
        ConsumerThread c3 = new ConsumerThread(resource,"消费者3");

        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
        c1.start();
        c2.start();
        c3.start();
    }
}


package com.yg.edu.queue.test;

/**
 * @author 史凯强
 * @date 2021/10/27 13:32
 * @desc
 **/
public class ConsumerThread extends Thread{
    private Resource resource;

    public ConsumerThread(Resource resource,String threadName){
        this.resource = resource;
        setName(threadName);
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep((long) (1000 * Math.random()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.remove();
        }
    }
}


package com.yg.edu.queue.test;

/**
 * @author 史凯强
 * @date 2021/10/27 13:31
 * @desc
 **/
public class ProducerThread extends Thread{
    private Resource resource;

    public ProducerThread(Resource resource,String threadName){
        this.resource = resource;
        setName(threadName);
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep((long) (1000 * Math.random()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.add();
        }
    }
}


package com.yg.edu.queue.test;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @author 史凯强
 * @date 2021/10/27 13:32
 * @desc
 **/
public class Resource {
    private BlockingQueue resourceQueue = new LinkedBlockingQueue(10);

    public void remove() {
        try {
            resourceQueue.take();
            System.out.println(Thread.currentThread().getName() +
                    "消耗一件资源," + "当前资源池有" + resourceQueue.size()
                    + "个资源");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void add() {
        try {
            resourceQueue.put(1);
            System.out.println(Thread.currentThread().getName()
                    + "生产一件资源," + "当前资源池有" + resourceQueue.size() +
                    "个资源");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

ArrayBlockingQueue源码解析

对于ArrayBlockingQueue需要掌握以下几点

  • 创建
  • 入队（添加元素）
  • 出队（删除元素）

创建

public ArrayBlockingQueue(int capacity, boolean fair)
public ArrayBlockingQueue(int capacity)

使用方式

Queue<String> abq = new ArrayBlockingQueue<String>(2);
Queue<String> abq = new ArrayBlockingQueue<String>(2,true);

通过使用方法，可以看出ArrayBlockingQueue 支持ReentrantLock的公平锁模式与非公平锁模式。

//底层数据结构
final Object[] items;

//用来为下一个take/poll/remove的索引（出队）
int takeIndex;

//用来为下一个put/offer/add的索引（入队）
int putIndex;

//队列中元素的个数
int count;

/*
 * Concurrency control uses the classic two-condition algorithm
 * found in any textbook.
 */

/** Main lock guarding all access */
final ReentrantLock lock;//锁

/** Condition for waiting takes */
private final Condition notEmpty;//等待出队的条件

/** Condition for waiting puts */
private final Condition notFull;//等待入队的条件

/**
 * 创造一个队列，指定队列容量，指定模式
 * @param fair
 * true：先来的线程先操作
 * false：顺序随机
 */
public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = new Object[capacity];//初始化类变量数组items
    lock = new ReentrantLock(fair);//初始化类变量锁lock
    notEmpty = lock.newCondition();//初始化类变量notEmpty Condition
    notFull =  lock.newCondition();//初始化类变量notFull Condition
}

/**
 * 创造一个队列，指定队列容量，默认模式为非公平模式
 * @param capacity <1会抛异常
 */
public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}

注意：

  • ArrayBlockingQueue的组成：一个对象数组+1把锁ReentrantLock+2个条件Condition
  • 在查看源码的过程中，也要模仿带条件锁的使用，这个双条件锁模式是很经典的模式

入队

public boolean offer(E e)

原理：
在队尾插入一个元素， 如果队列没满，立即返回true； 如果队列满了，立即返回false
使用方法：
abq.offer(“hello1”);

/**
 * 在队尾插入一个元素，
 * 如果队列没满，立即返回true；
 * 如果队列满了，立即返回false
 * 注意：该方法通常优于add(),因为add()失败直接抛异常
 */
public boolean offer(E e) {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        if (count == items.length)//数组满了
            return false;
        else {//数组没满
            enqueue(e);//插入一个元素
            return true;
        }
    } finally {
        lock.unlock();
    }
}

private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    items[putIndex] = x;//插入元素
    if (++putIndex == items.length)
        putIndex = 0;
    count++;//元素数量+1
    /**
     * 唤醒一个线程
     * 如果有任意一个线程正在等待这个条件，那么选中其中的一个区唤醒。
     * 在从等待状态被唤醒之前，被选中的线程必须重新获得锁
     */
    notEmpty.signal();
}

代码非常简单，流程看注释即可，只有一点注意点：
在插入元素结束后，唤醒等待notEmpty条件（即获取元素）的线程，可以发现这类似于生产者-消费者模式

public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException

原理：
在队尾插入一个元素,，如果数组已满，则进入等待，直到出现以下三种情况：

  • 被唤醒
  • 等待时间超时
  • 当前线程被中断

使用方法

try {
    abq.offer("hello2",1000,TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
    e.printStackTrace();
}

/**
 * 在队尾插入一个元素,
 * 如果数组已满，则进入等待，直到出现以下三种情况：
 * 1、被唤醒
 * 2、等待时间超时
 * 3、当前线程被中断
 */
public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {

    checkNotNull(e);
    long nanos = unit.toNanos(timeout);//将超时时间转换为纳秒
    final ReentrantLock lock = this.lock;
    /*
     * lockInterruptibly():
     * 1、 在当前线程没有被中断的情况下获取锁。
     * 2、如果获取成功，方法结束。
     * 3、如果锁无法获取，当前线程被阻塞，直到下面情况发生：
     * 1）当前线程(被唤醒后)成功获取锁
     * 2）当前线程被其他线程中断
     * 
     * lock()
     * 获取锁，如果锁无法获取，当前线程被阻塞，直到锁可以获取并获取成功为止。
     */
    lock.lockInterruptibly();//加可中断的锁
    try {
        while (count == items.length) {//队列已满
            if (nanos <= 0)//已超时
                return false;
            /*
             * 进行等待：
             * 在这个过程中可能发生三件事：
             * 1、被唤醒-->继续当前这个for(;;)循环
             * 2、超时-->继续当前这个for(;;)循环
             * 3、被中断-->之后直接执行catch部分的代码
             */
            nanos = notFull.awaitNanos(nanos);//进行等待（在此过程中，时间会流失,在此过程中，线程也可能被唤醒）
        }
    
        enqueue(e);
        return true;
    } finally {
        lock.unlock();
    }
}

注意：

  • awaitNanos(nanos)是AQS中的一个方法，这里就不详细说了，有兴趣的自己去查看AQS的源代码。
  • lockInterruptibly()与lock()的区别见注释

public void put(E e) throws InterruptedException

原理：
在队尾插入一个元素，如果队列满了，一直阻塞，直到数组不满了或者线程被中断

 try {
    abq.put("hello1");
} catch (InterruptedException e) {
    e.printStackTrace();
}

/**
 * 在队尾插入一个元素
 * 如果队列满了，一直阻塞，直到数组不满了或者线程被中断
 */
public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == items.length)//队列满了，一直阻塞在这里
        	/*
             * 一直等待条件notFull，即被其他线程唤醒
             * （唤醒其实就是，有线程将一个元素出队了，然后调用notFull.signal()唤醒其他等待这个条件的线程，同时队列也不慢了）
             */
            notFull.await();
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

出队

public E poll()

原理：
如果没有元素，直接返回null；如果有元素，将队头元素置null，但是要注意队头是随时变化的，并非一直是items[0]。
使用方法：
abq.poll();

/**
 * 出队
 */
 public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return (count == 0) ? null : dequeue();//如果没有元素，直接返回null，而非抛出异常
    } finally {
        lock.unlock();
    }
}

/**
 * 出队
 */
private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];//获取出队元素
    items[takeIndex] = null;//将出队元素位置置空
    /*
     * 第一次出队的元素takeIndex==0,第二次出队的元素takeIndex==1
     * (注意：这里出队之后，并没有将后面的数组元素向前移)
     */
    if (++takeIndex == items.length)
        takeIndex = 0;
    count--;//数组元素个数-1
    if (itrs != null)
        itrs.elementDequeued();
    notFull.signal();//数组已经不满了，唤醒其他等待notFull条件的线程
    return x;//返回出队的元素
}

public E poll(long timeout, TimeUnit unit) throws InterruptedException

原理：
从队头删除一个元素，如果数组不空，出队；如果数组已空且已经超时，返回null；如果数组已空且时间未超时，则进入等待，直到出现以下三种情况：

  • 被唤醒
  • 等待时间超时
  • 当前线程被中断
try {
    abq.poll(1000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
    e.printStackTrace();
}

/**
 * 从对头删除一个元素,
 * 如果数组不空，出队；
 * 如果数组已空，判断时间是否超时，如果已经超时，返回null
 * 如果数组已空且时间未超时，则进入等待，直到出现以下三种情况：
 * 1、被唤醒
 * 2、等待时间超时
 * 3、当前线程被中断
 */
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);//将时间转换为纳秒
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0) {
            if (nanos <= 0)//时间超时
                return null;
            /*
             * 进行等待：
             * 在这个过程中可能发生三件事：
             * 1、被唤醒-->继续当前这个for(;;)循环
             * 2、超时-->继续当前这个for(;;)循环
             * 3、被中断-->之后直接执行catch部分的代码
             */
            nanos = notEmpty.awaitNanos(nanos);
        }
        return dequeue();//数组不空//出队
    } finally {
        lock.unlock();
    }
}

public E take() throws InterruptedException

原理：
将队头元素出队，如果队列空了，一直阻塞，直到数组不为空或者线程被中断

try {
    abq.take();
} catch (InterruptedException e) {
    e.printStackTrace();
}

/**
 * 将队头元素出队
 * 如果队列空了，一直阻塞，直到数组不为空或者线程被中断
 */
public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0)//如果数组为空，一直阻塞在这里
        	/*
             * 一直等待条件notEmpty，即被其他线程唤醒
             * （唤醒其实就是，有线程将一个元素入队了，然后调用notEmpty.signal()唤醒其他等待这个条件的线程，同时队列也不空了）
             */
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

在这里插入图片描述

三种入队对比

offer(E e)：如果队列没满，立即返回true； 如果队列满了，立即返回false–>不阻塞
put(E e)：如果队列满了，一直阻塞，直到数组不满了或者线程被中断–>阻塞
offer(E e, long timeout, TimeUnit unit)：在队尾插入一个元素,，如果数组已满，则进入等待，直到出现以下三种情况：–>阻塞
被唤醒
等待时间超时
当前线程被中断

三种出队对比

poll()：如果没有元素，直接返回null；如果有元素，出队
take()：如果队列空了，一直阻塞，直到数组不为空或者线程被中断–>阻塞
poll(long timeout, TimeUnit unit)：如果数组不空，出队；如果数组已空且已经超时，返回null；如果数组已空且时间未超时，则进入等待，直到出现以下三种情况：
被唤醒
等待时间超时
当前线程被中断

yemuxiaweiliang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
AQS-3抽象队列同步器
09-15
AQS_3抽象队列同步器
AQS抽象队列同步器,AQS抽象队列同步器
09-15
AQS抽象队列同步器,AQS抽象队列同步器
【并发】7、抽象队列同步器AQS应用之阻塞队列BlockingQueue
flora
01-27 189
抽象队列同步器AQS应用之阻塞队列BlockingQueueArrayBlockingQueue 类重要属性构造器put()方法AQSawait() BlockingQueue是线程间通信的工具，在任意时刻、不管并发有多高，在单JVM上，同一时间永远都只有一个线程能够对队列进行入队或出队操作。 BlockingQueue的特性： 是线程安全的 应用场景： 对于生产者消费者场景很适合 线程池 springcloud-Euraka的三级缓存 Nacos Netty MQ（Roketmq） 所有的阻塞队
并发编程五（AQS应用之BlockingQueue（同步阻塞队列））
xingze的博客
12-02 513
文章目录1. Queue、Deque、BlockingQueue2. BlockingQueue3. BlockingQueue的实现类（7种）3.1 ArrayBlockingQueue3.2 LinkedBlockingQueue3.3 PriorityBlockingQueue3.4 DelayQueue3.5 SynchronousQueue3.6 LinkedBlockingDeque3...
AQS应用BlockingQueue
qq_42001445的博客
09-06 228
阻塞队列BlockingQueue 常见的4中阻塞队列： 1、ArrayBlockingQueue由数组支持的有界队列； 2、LinkedBlockQueue由链接节点至此的可选有界队列 3、PriorityBlockingQueue由优先级堆至此的无界优先级队列； 4、DelayQueue由优先级堆至此的无界优先级队列； 队列的概念： 1、线程安全，由lock锁来保证其互斥性；可以有多个消费者，多个提供者来操作，但是每一次只能由一个来做一个动作，无论是出队还是入队都需要获取这把锁才能进行操作；并且符合队列
抽象队列同步器AQS应用之BlockingQueue
沮丧的南瓜
05-30 249
概要 BlockingQueue，是java.util.concurrent 包提供的用于解决并发生产者 - 消费者问题的最有用的类，它的特性是在任意时刻只有一个线程可以进行take或者put操作，并且BlockingQueue提供了超时return null的机制，在许多生产场景里都可以看到这个工具的身影。 一、队列类型 无限队列 （unbounded queue ） - 几乎可以无限增长 有限队列 （ bounded queue ） - 定义了最大容量 二、队列数据结构 队列实质就是一种存储数据的结
AQS(03)--LinkedBlockingQueue
qq_29978863的博客
03-16 190
https://www.processon.com/view/link/5e5a6068e4b0541c5e1418a0
AQS抽象队列同步器2
09-15
AQS抽象队列同步器2
浅谈Java并发 J.U.C之AQS：CLH同步队列
08-26
浅谈Java并发 J.U.C之AQS：CLH同步队列 在 Java 并发编程中，J.U.C（Java Utility Classes）提供了一些高效的并发工具，其中AQS（AbstractQueuedSynchronizer）是一个核心组件之一。AQS内部维护着一个FIFO队列，即...
AQS底层源码解析-BlockingQueue源码探究
Eriksen的博客
03-07 555
AQS底层源码解析-BlockingQueue源码探究
同步阻塞队列使用以及原理
qq_39673469的博客
08-20 429
抽象队列同步器-阻塞队列概要队列类型队列数据接口常见的4中阻塞度列ArrayBlockingQueue成员变量构造方法put(E e)操作take()操作原理图示 概要 阻塞队列（BlockingQueue）是由 java.util.concurrent 提供的用于解决并发生产者-消费者最常用的类,特点是在任意时刻只有一个线程可以执行存/取操作. 它额外支持在检索元素时等待队列变为非空，并在存储元素时等待队列中的空间变为可用的操作。 BlockingQueue方法有四种形式，它们有不同的方法来处理不能立即满
抽象队列同步器AQS应用之BlockingQueue详解
Joanna_or_zhouzhou的博客
05-10 227
概要   BlockingQueue，是java.util.concurrent 包提供的用于解决并发生产者 - 消费者问题的最有用的类，它的特性是在任意时刻只有一个线程可以进行take或者put操作，并且BlockingQueue提供了超时return null的机制，在许多生产场景里都可以看到这个工具的身影。抽象队列同步器AQS应用之BlockingQueue详解。
死磕java concurrent包系列（五）基于AQS的条件队列把LinkedBlockingQueue“扒光”
weixin_33862514的博客
12-11 189
LinkedBlockingQueue的基础 LinkedBlockingQueue是一个基于链表的阻塞队列，实际使用上与ArrayBlockingQueue完全一样，我们只需要把之前烤鸡的例子中的Queue对象替换一下即可。如果对于ArrayBlockingQueue不熟悉，可以去看看https://juejin.im/post/5c0f79f3f265da61561f1bec LinkedBl...
【学习笔记】抽象队列同步器AQS应用之BlockingQueue详解
qq_41358574的博客
12-31 731
文章目录什么是AQS框架Aqs核心源码基于aqs实现的锁BlockingQueueArrayBlockingQueueLinkedBlockingQueueDelayQueueBlockingQueue API多线程生产者-消费者示例 什么是AQS框架 1、AQS是一个JAVA线程同步的框架。是JDK中很多锁工具的核心实现框架。 2、在AQS中,维护了一个信号量 state和一个线程组成的双向链表队列。其中,这个线程队列,是用来给线程排队的,而state就像是一个红绿灯,用来控制线程排队或放行的。在不同的场
AQS-condition阻塞队列 [自定义同步器框架]
weixin_33834137的博客
05-08 108
2019独角兽企业重金招聘Python工程师标准>>> ...
java 队列同步,Java中的阻塞队列（3）同步计数器
weixin_42525264的博客
03-21 83
9、同步计数器 CountDownLatch这是一个同步的辅助类，实现原理为AbstractQueuedSynchronizer抽象队列化同步器图9-1方法介绍：1、CountDownLatch(int count)：构造，并给定计数初始化2、await()：当前线程在锁存器倒计数到零之前一直等待，除非线程被中断3、await(long, TimeUnit)：当前线程在锁存器倒计数到零之前一直等待...
深入浅出AQS条件队列以及阻塞队列BlockingQueue
不会起名
09-13 1053
文章目录前言AQS中的条件队列BlockingQueue的结构ArrayBlockingQueue源码生产者putnotFull.await()消费者take图解总结 前言 之前讲过独占共享模式下Node节点的waitStatus信号量还有一个CONDITION = -2;没有说，并且AQS中还有一个ConditionObject内部类没有提到和条件队列下使用到的一些方法 AQS中的条件队列 static final class Node { /** * 标记节点为独占模
(SUB)LOCK与AQS详解
jay的博客
09-08 200
AQS AQS和Lock接口的关系 Lock接口定义了锁的实现规范，锁类通过聚合AQS来实现锁，然后通过集成Lock接口来实现锁的更多的功能。通过Lock接口和AQS实现了独占锁，共享锁，可重入锁，可重入读写锁，公平锁和非公平锁。LockSupport，和Conditoin实现了一个等待队列，类似于同步锁中的wait和notify方法。这些锁与同步锁不同的是**，首先这些是显示的释放锁和显示的获取锁，不像同步锁是隐式的，这样操作要灵活一点，然后同步锁升级为重量级锁后一旦没抢占到就要进入阻塞状态，而这些.
并发编程之——AQS原理和阻塞队列变化
做最亮的星星
02-02 2894
1、AQS简介 2、源码分析 2.1 线程阻塞 2.2 线程唤醒 1、AQS简介 AQS全名：AbstractQueuedSynchronizer，它就是Java的一个抽象类，它的出现是为了解决多线程竞争共享资源而引发的安全问题，细致点说AQS具备一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中，队列是双向队列。 常用...
Java并发编程：深入解析抽象队列同步器(AQS)及其在Lock中的应用
最新发布
12-11
本文深入探讨了Java并发编程的关键组件——抽象队列同步器（AQS）及其在ReentrantLock的应用。AQS是处理线程同步问题的高效工具，是Java并发编程中的核心。文章首先简要介绍了并发编程领域的先驱Doug Lea。 重点在于ReentrantLock的分析，它是基于AQS实现的互斥锁。相比synchronized，它提供了更多特性，如手动加锁解锁，以及公平和非公平锁的选择。公平锁（FairSync）和非公平锁（NonfairSync）的实现是通过AQS的扩展来实现的。 文章进一步阐释了AQS的多项特性，包括阻塞等待队列、共享/独占模式、公平/非公平锁定、可重入性，以及允许中断的能力。AQS作为基础框架，支持了多种同步机制的实现，例如LatchBarrierBlockingQueue等。AQS通过内部类Sync映射所有同步器调用，维护资源状态的可用性 最后，文档提供了AQS源码的初步分析，突出了其设计和实现的关键部分，如等待队列节点类Node的定义 综合来看，文章为Java开发者提供了对AQS及其在ReentrantLock中应用的详细理解，是探索Java并发编程核心概念

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yemuxiaweiliang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值