【并发编程】-4.Lock接口与AQS

于 2024-07-24 22:31:04 发布
阅读量999 收藏 13
点赞数 31
分类专栏： 并发编程 文章标签： 开发语言 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xrl00/article/details/140674869
版权

Lock接口概念

  1. 概念：JDK1.5时，在Java.uitl.concurrent并发包中添加了Lock锁接口，其中定义了lock()、unLock()、tryLock()、lockInterruptibly()、newCondition()等一系列接口，它属于是JAVA语言层面的内置锁；
  2. 特性：
    1. 显示锁：不同于synchronized隐式锁，锁的获取和释放都是隐式的由JVM来管理，不需要开发人员手动实现；而显示锁的获取和释放都需要开发人员手动编码实现；
    2. 非阻塞式获取锁：定义了tryLock()方法，可以在获取锁时设置超时时长，达到超时时间还未获取到锁会返回一个false；
    3. 支持中断获取锁：定义了lockInterruptibly()方法，可以接受中断信号；
    4. 多条件等待唤醒机制Condition：Condition定义了一系列线程之间通信方法，能更细粒度的进行线程间的通信；

Lock接口和synchronized的比较

  1. 锁的类型比较：

    1. 公平/非公平：synchronized是非公平锁；ReentrantLock可以是公平锁也可以是非公平锁；具体可参考；
    2. 都是可重入锁；
    3. 都为悲观锁；

  2. 锁的获取与释放比较：Lock是显示锁必须手动获取，手动释放；而synchronized是隐式锁，锁的获取与释放由JVM来管理；

    1. Lock可以获取多个锁:ReentrantReadWriteLock中的读锁获取 reentrantReadWriteLock.readLock().lock();
    2. Lock可以通过tryLock()方法非阻塞式获取锁；

  3. 异常情况：

    1. synchronized在发生异常的时候，会自动释放线程占有的锁
    2. ReentrantLock在发生异常时，如果没有通过unlock去释放锁，很有可能造成死锁，因此需要在finally块中释放锁；

  4. 线程调度比较：

    1. synchronized: 使用Object对象本身的wait 、notify、notifyAll调度机制；
    2. Lock: 使用Condition中的signal(); await();等， 进行线程之间的调度；

Lock接口的使用

Lock接口中的核心方法

public interface Lock {

    /**
   	 * 尝试获取锁，若资源空闲则直接获取锁，否则阻塞等待
     */
    void lock();

    /**
   	 * 与lock()方法作用类似，只是若没有获取到锁阻塞时，可以接受中断命令，中断获取锁
     */
    void lockInterruptibly() throws InterruptedException;

    /**
   	 * 尝试非阻塞获取锁并立刻返回，若资源空闲则直接获取锁并返回true，否则直接返回false不会阻塞等待；
     */
    boolean tryLock();
    
    /**
   	 * tryLock()方法作用类似，只是设置了获取锁的等待时间，在等待时间内阻塞获取锁，获取到锁返回true，否则返回false;
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
   	 * 释放锁
     */
    void unlock();
    
    /**
   	 * 可以将一个condition实例绑定到lock实例上，然后可以通过signal(); await();等方法，对锁线程进行调度
     */
    Condition newCondition();
}

Lock接口的实现类：

ReentrantLock：

独占锁，可重入锁，公平/非公平锁，可中断锁；

简单使用案例：
package com.xrl.juc.lock_demo;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author xrl
 * @date 2024/7/16 22:47
 */
public class ReentrantLockTest implements Runnable{
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        get();
    }
    private void get() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread() + "---------get()方法");
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        ReentrantLockTest lockTest = new ReentrantLockTest();
        new Thread(lockTest).start();
        new Thread(lockTest).start();
        new Thread(lockTest).start();
        new Thread(lockTest).start();
        new Thread(lockTest).start();
    }
}

ReentrantReadWriteLock：

  1. 读写锁：一般在读多写少情况下使用。有两把锁一把读锁，一把写锁写锁是独占式的，读锁是共享式的
  2. 实现原理：底层使用AQS实现，同步状态的实现是在一个整形变量上通过“按位切割使用”；将变量切割成两部分，高16位表示读状态，也就是获取到读锁的次数，低16位表示获取到写线程的可重入次数，并通过CAS对其进行操作实现读写分离；
  3. 三个特性：
    1. 公平性：支持公平和非公平两种模式。
    2. 重入性：支持重入，读写锁都支持最多65535个。
    3. 锁降级：先获取写锁，再获取读锁，再释放写锁，写锁就能降级为读锁。
简单案例
package com.xrl.juc.lock_demo;

import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 有两把锁,一把读锁一把写锁,同一个线程中可以同时拥有两把锁但必须先获取 writeLock 再获取 readLock
 * 读锁可以有多个线程共有,写锁只能一个线程
 * 在有读锁的情况下没有写锁,有写锁的小情况下只有拥有写锁的那个线程可以有读锁
 * 读多写少情况下使用
 *
 * @author xrl
 * @date 2024/7/16 23:27
 */
public class ReentrantReadWriteLockeTest {
    /**
     * 可重入的读写锁
     *  ReadWriteLock接口需要实现两把锁
     *
     */
    private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    private static  ExecutorService threadPool= Executors.newFixedThreadPool(5);
    /**
     * 让线程同步争抢锁
     */
    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

    private static int i = 100;

    public static void main(String[] args) {
        //通过 cyclicBarrier 使三个线程同步运行
        threadPool.execute(() -> {
            write(Thread.currentThread());
        });
        threadPool.execute(() -> {
            read(Thread.currentThread());
        });
        threadPool.execute(() -> {
            read(Thread.currentThread());
        });
        threadPool.shutdown();
    }

    private static void write(Thread thread) {
        try {
            //线程阻塞, 让线程同步争抢锁
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }

        //获取写锁
        reentrantReadWriteLock.writeLock().lock();
        //获取读锁
//        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println("写线程开始运行" + thread.getName() + " : i=" + i);
            Thread.sleep(1000);
            i = 1;
            System.out.println(thread.getName() + "运行完" + " : i=" + i );
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放锁
            System.out.println("释放锁");
            reentrantReadWriteLock.writeLock().unlock();
        }
    }
    private static void read(Thread thread) {
        try {
            //线程阻塞, 让线程同步争抢锁
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        // 线程请求后阻塞至写完成
        System.out.println("线程请求读锁");
        reentrantReadWriteLock.readLock().lock();
        System.out.println("得到读锁");
        //获取写锁
//        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println("读线程开始运行" + thread.getName() + " : i=" + i);
            Thread.sleep(1000);
            System.out.println(thread.getName() + "运行完");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放锁
            reentrantReadWriteLock.readLock().unlock();
        }
    }
}

结果，说明获得写锁和获得读锁的线程不能同时运行，获得读锁的线程可以同时运行

写线程开始运行pool-1-thread-1 : i=100
pool-1-thread-1运行完 : i=1
读线程开始运行pool-1-thread-2 : i=1
读线程开始运行pool-1-thread-3 : i=1
pool-1-thread-2运行完
pool-1-thread-3运行完

AQS

  1. 概念：AQS是AbstractQueuedSynchronizer抽象类的简称，它通过模板模式的设计模式构建，其内部除了提供并发操作核心方法以及同步队列操作外，还提供了一些模板方法让子类自己实现，如加锁操作及解锁操作，从而使AQS只关注内部公共方法实现并不关心外部不同模式的具体逻辑实现；

    模板方法如下；ReentrantLock实现的是tryAcquire(int arg)、tryRelease(int arg)、isHeldExclusively()

    //独占模式下获取锁的方法
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}
//独占模式下释放锁的方法
protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}
//共享模式下获取锁的方法
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}
//共享模式下释放锁的方法
protected boolean tryReleaseShared(int arg) {
    throw new UnsupportedOperationException();
}
//判断是否持有独占锁的方法
protected boolean isHeldExclusively() {
    throw new UnsupportedOperationException();
}

核心属性：

  1. 同步状态：AQS内部通过一个用volatile修饰的int类型变量state作为同步状态private volatile int state;；当state为0时，代表着当前没有线程占用锁资源，反之不为0时，代表着锁资源已经被线程持有，通过CAS设置值；
  2. Node内部类（同步队列的节点）：当锁资源已经被占用时（state != 0），则当前线程则会被封装成一个Node节点加入同步队列进行等待，Node节点主要包括了当前执行的线程本身、线程的状态，是否被阻塞、是否处于等待唤醒、是否中断等；每个Node节点中都关联着前驱节点prev以及后继节点next，从而构成一个双端队列；
  3. 同步队列：由上述未获取到锁资源的节点Node构成的FIFO双端队列，被称之为CLH队列，并在AQS中维护了两个变量private transient volatile Node head; 和private transient volatile Node tail;分别指向CLH队列的头和尾，方便数据新增和添加；
  4. 阻塞队列：AQS使用内部类ConditionObject用来构建等待队列，当Condition调用await()方法后，等待获取锁资源的线程将会加入等待队列中，而当Condition调用signal()方法后，线程将会从等待队列转移到同步队列；

原理分析

  1. AQS主要内部维护着一个由Node节点构成的FIFO的同步队列；
  2. 当一个线程执行ReetrantLock.lock()加锁方法获取锁失败时，该线程会被封装成Node节点加入同步队列等待锁资源的释放，期间不断执行自旋等待；
  3. 当该线程所在节点的前驱节点为队列头结点时，当前线程就会开始尝试对同步状态标识state进行修改(+1)，如果可以修改成功则代表获取锁资源成功，然后将自己所在的节点设置为队头head节点，表示自己已经持有锁资源;
  4. 当一个线程调用ReetrantLock.unlock()释放锁时，最终会调用Sync内部类中的tryRelease(int releases)方法再次对同步状态标识state进行修改(-1)，成功之后唤醒当前线程所在节点的后继节点中的线程。

ReentrantLock源码分析

  1. ReentrantLock是Lock接口的实现类，当我们在new ReentrantLock();时，实际是创建了一个内部类Sync（同步器）的子类sync = new NonfairSync();，它拥有两个子类一个为公平锁一个为非公平锁sync = fair ? new FairSync() : new NonfairSync();；

    当ReentrantLock调用方法时，大部分方法实际都是调用sync 类中的方法，如：public void lock() { sync.lock(); }

    由下面代码可知sync继承AbstractQueuedSynchronizer抽象类简称AQS；

    public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;

    private final Sync sync;
    
    abstract static class Sync extends AbstractQueuedSynchronizer {

ReentrantLock方法说明：

    //构造器
    //默认构造器创建非公平锁
    public ReentrantLock();

    //传入一个Boolean类型的参数，true创建一个公平锁，false非公平
    public ReentrantLock(boolean fair);

    // 查询当前线程调用lock()的次数
    int getHoldCount() 

    // 返回目前持有此锁的线程，如果此锁不被任何线程持有,返回null  
    protected Thread getOwner(); 

    // 返回一个集合，它包含可能正等待获取此锁的线程，其内部维持一个队列(后续分析)
    protected Collection<Thread> getQueuedThreads(); 

    // 返回正等待获取此锁资源的线程估计数
    int getQueueLength();

    // 返回一个集合，它包含可能正在等待与此锁相关的Condition条件的线程(估计值)
    protected Collection<Thread> getWaitingThreads(Condition condition); 

    // 返回调用当前锁资源Condition对象await方法后未执行signal()方法的线程估计数
    int getWaitQueueLength(Condition condition);

    // 查询指定的线程是否正在等待获取当前锁资源
    boolean hasQueuedThread(Thread thread); 

    // 查询是否有线程正在等待获取当前锁资源
    boolean hasQueuedThreads();

    // 查询是否有线程正在等待与此锁相关的Condition条件
    boolean hasWaiters(Condition condition); 

    // 返回当前锁类型，如果是公平锁返回true，反之则返回flase
    boolean isFair() 

    // 查询当前线程是持有当前锁资源
    boolean isHeldByCurrentThread() 

    // 查询当前锁资源是否被线程持有
    boolean isLocked()

核心方法解析

构造方法：

  1. public ReentrantLock(boolean fair);构造方法返回的是，实现了AQS抽象类中部分方法的抽象类Sync的子类。

    sync = fair ? new FairSync() : new NonfairSync();

    FairSync 和 NonfairSync两个对象的实现大致相同 ，只是一个是公平性的，一个是非公平性的；

    两者之前的区别在于FairSync使用lock()方法获取锁之前，会先去判断同步队列中是否存在元素（hasQueuedPredecessors()方法），如果存在则将当前任务放入同步队列的队尾；

    NonfairSync只判断当前锁是否有人占用，如果没有就直接获取；

lock()方法

  1. lock()方法，底层是调用的是AQS中的模板方法acquire(int arg)；

     public final void acquire(int arg) {
     	// 调用子类中重写的`tryAcquire`判断能否获得资源；
        if (!tryAcquire(arg) &&
            // 将当前线程封装为一个`Node`节点，加入同步队列中；
            // 在同步队列中等待同步资源的释放，当线程争取到同步资源 的使用权后，线程中同步队列中出队；
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            // 
            selfInterrupt();
    }

  2. tryAcquire(arg) ：调用子类中重写的tryAcquire判断能否获得资源；

    protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 得到当前锁的状态
    int c = getState();
    // 锁的状态为0时，表示现在锁没有被占用
    if (c == 0) {
        //hasQueuedPredecessors()判断当前的同步队列中是否存在元素，当前元素是不是队头元素，是公平锁和非公平锁的区别所在
        if (!hasQueuedPredecessors() &&
            	// CAS修改state同步状态的值
                compareAndSetState(0, acquires)) {
            // 给当前线程设置独占访问权（拿到锁了）
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果当前线程等于持有锁的线程（锁的重入）
    else if (current == getExclusiveOwnerThread()) {
        // 计数加一
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        // 修改同步状态的值
        setState(nextc);
        return true;
    }
    // 到这里说明没有拿到锁，返回false
    return false;
}

  3. acquireQueued(addWaiter(Node.EXCLUSIVE), arg)：在同步队列中等待同步资源的释放，当线程争取到同步资源 的使用权后，线程中同步队列中出队；

    final boolean acquireQueued(final Node node, int arg) {
    // 是否获取到资源标记
    boolean failed = true;
    try {
        // 中断标识
        boolean interrupted = false;
        // 自旋 
        for (;;) {
            // 获得传入节点的前驱节点
            final Node p = node.predecessor();
            // 如果当前节点的前驱节点节点等于头节点，且可以获得资源
            if (p == head && tryAcquire(arg)) {
                // 将当前结点设置为头节点
                setHead(node);
                // 设置原头结点的后继节点为null,帮助jvm回收垃圾；（能静方法说明头节点线程加锁操作已运行完成）
                p.next = null; // help GC
                // 标记已经成功获取同步资源
                failed = false;
                return interrupted;
            }
            // 当前节点不是头节或者获取资源失败
            // shouldParkAfterFailedAcquire(p, node)线程获取资源失败后，判断是否阻塞线程
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 阻塞线程等待其他线程唤醒，并判断中断状态
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            // 如果最终都没能成功获取同步状态，结束该线程的请求
            cancelAcquire(node);
    }
}

    1. shouldParkAfterFailedAcquire(p, node)：线程获取资源失败后，判断是否阻塞线程

      private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 得到前驱节点的同步状态
    int ws = pred.waitStatus;
    // 等于阻塞状态
    if (ws == Node.SIGNAL)
        // 返回ture说明要阻塞当前线程，等待前驱节点释放资源，唤醒后继节点 执行parkAndCheckInterrupt()
        return true;
    // 前驱状态大于0，说明state是CANCELLED，线程是已取消的
    if (ws > 0) {
        // 将同步队列中已经标记已取消的节点全部剔除
        do {
            // 从同步队列中去掉pred节点，（将后继节点的前驱节点改为这个节点的前驱节点
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 同步状态不大于0，状态是初始态或propagate态（在共享模式同步状态可以进行传播），则通过CAS将pred的状态改为SIGNAL阻塞状态
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

    2. parkAndCheckInterrupt()：阻塞线程等待其他线程唤醒，并判断中断状态

      private final boolean parkAndCheckInterrupt() {
    // 阻塞当前线程，底层是使用了Unsafe类提供的方法来实现线程的park（阻塞）和unpark（唤醒）操作
    // 方法内部，调用 setBlocker(t, blocker);方法，将当前线程关联到指定的同步对象blocker，标记当前线程由该对象导致阻塞
    // 之后调用UNSAFE.park(false, 0L)方法阻塞线程，第一个参数false表示不相对时间进行阻塞，第二个参数0L表示无期限地阻塞当前线程，直到有其他线程唤醒
    // 当有线程唤醒当前线程时，再次调用setBlocker(t, null);解除线程和对象直接的关联
    LockSupport.park(this);
    // 判断当前线程是否已被中断，返回中断标识，并清除中断标识
    return Thread.interrupted();
}

    3. addWaiter(Node.EXCLUSIVE)：将当前线程封装为一个Node节点，加入同步队列中；

      private Node addWaiter(Node mode) {
    // 将当前线程封装为一个节点
    Node node = new Node(Thread.currentThread(), mode);

    Node pred = tail;
    // 尾结点不为空
    if (pred != null) {
        // 将当前接节点插入队尾
        node.prev = pred;
        // CAS设置尾结点
        if (compareAndSetTail(pred, node)) {
            // 构成双端队列，将前一个元素指向下一个元素
            pred.next = node;
            // 设置成功，返回当前接节点
            return node;
        }
    }
    // 尾节点为空也就是同步队列为空 或 CAS设置尾结点失败
    enq(node);
    return node;
}

    4. enq(node)：将节点插入队列，队列为空时初始化

      private Node enq(final Node node) {
    // 自旋
    for (;;) {
        Node t = tail;
        // 尾节点为空
        if (t == null) { 
            // cas 初始化头节点
            if (compareAndSetHead(new Node()))
                // 没有节点时，头尾相等
                tail = head;
        } else {
            // 将当前元素插入同步队列中，同addWaiter中的逻辑
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

unlock()方法

  1. 底层调用的是AQS的release(1);方法；

    public final boolean release(int arg) {
    // 尝试释放锁  ReentrantLock实现的模板方法
    if (tryRelease(arg)) {
        Node h = head;
        // 头节点不为空 且 节点状态不为初始状态
        if (h != null && h.waitStatus != 0)
            // 唤醒同步队列的后继节点
            unparkSuccessor(h);
        return true;
    }
    return false;
}

    1. tryRelease(arg)：尝试释放锁 ReentrantLock实现的模板方法

      protected final boolean tryRelease(int releases) {
    // 计算同步状态
    int c = getState() - releases;
    // 如果当前释放锁的线程不为持有锁的线程则抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 判断状态是否为0，如果是则说明已释放同步状态
    if (c == 0) {
        free = true;
        // 设置Owner为null
        setExclusiveOwnerThread(null);
    }
    // 修改同步状态
    setState(c);
    return free;
}

    2. unparkSuccessor(h);： 唤醒同步队列的后继节点

      private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    // 节点阻塞状态小于0，说明节点没有被取消
    if (ws < 0)
        // 将节点阻塞状态设置为0
        compareAndSetWaitStatus(node, ws, 0);
    Node s = node.next;
    // 后继节点为null或者为取消状态
    if (s == null || s.waitStatus > 0) {
        s = null;
        //  寻找到下一个非取消态的结点 （从同步队列队尾结点开始向前遍历，非空且不等于当前node ,则校验此结点t的状态）
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 唤醒结点t对应的线程
    if (s != null)
        LockSupport.unpark(s.thread);
}

实现总结

  1. 基础属性：

    1. 同步状态标识：标识锁资源的占有状态；
    2. 同步队列：存放获取锁失败的线程；
    3. 等待队列：用于实现多条件唤醒；
    4. Node节点：队列的每个节点，线程封装体；

  2. 基础操作：

    1. cas修改同步状态标识；
    2. 获取锁失败加入同步队列阻塞；
    3. 释放锁时唤醒同步队列第一个节点线程；

  3. 加锁操作：

    1. 调用tryAcquire()修改标识state，失败加入队列等待；
    2. 加入队列后判断节点是否为signal状态，是则调用LockSupport.park(this);阻塞挂起当前线程；
    3. 判断是否为cancel状态，是则往前遍历删除队列中所有cancel状态节点；
    4. 如果节点为0或者propagate状态则将其修改为signal状态；
    5. 阻塞被唤醒后如果为head则获取锁，成功返回true，失败则继续阻塞；

  4. 解锁操作：

    1. 调用tryRelease()释放锁修改标识state；
    2. 释放锁成功后唤醒同步队列后继阻塞的线程节点；
    3. 被唤醒的节点会自动替换当前节点成为head节点；

Condition接口

使用Condition可以实现类似于Object和wait()、notify()等线程间通信操作；具体实现可参考；原理参考；

简单案例

package com.xrl.juc.conditiontest;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 利用lock来替换synchronized实现 生产者,消费者模式
 *
 * @author shkstart
 * @create 2024-07-24 17:56
 */
public class producerConsumer {

    public static void main(String[] args) {
        AppleBox appleBox = new AppleBox();

        Producer producer = new Producer(appleBox);
        Consumer consumer = new Consumer(appleBox);
        Consumer consumer2 = new Consumer(appleBox);
        Thread p = new Thread(producer, "生产者");
        Thread c1 = new Thread(consumer, "消费者1");
        Thread c2 = new Thread(consumer2, "消费者2");
        p.start();
        c1.start();
        c2.start();
    }
}

class Apple {
    int id;
    public Apple(int id) {
        this.id = id;
    }
}

class AppleBox {
    AtomicInteger index = new AtomicInteger(0);
    AtomicReferenceArray<Apple> apples = new AtomicReferenceArray<>(new Apple[5]);
//    AtomicReference<Apple[]> apples = new AtomicReference<>();
    //创建锁对象 ,替换synchronized
    private final ReentrantLock lock = new ReentrantLock();
    //生产条件
    private final Condition produceCondition = lock.newCondition();
    //消费条件
    private final Condition consumeCondition = lock.newCondition();

    // public synchronized boolean deposite(Apple apple) {
    public boolean deposite(Apple apple) {
        lock.lock();
        try {
            while (index.get() == apples.length()) {
                //生产线程进入等待
                produceCondition.await();
                return false;
            }
            apples.set(index.getAndIncrement(), apple);
            //this.apples[index.incrementAndGet()] = apple;
            System.out.println(Thread.currentThread().getName() + "生产了: " + index.get());
            //唤醒消费线程
            consumeCondition.signal();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return false;
    }

    public Apple withdraw() throws Exception {
        lock.lock();
        try {
            while (index.get() == 0) {
                System.out.println(Thread.currentThread().getName() + "消费缺货" );
                consumeCondition.await();
            }
            Apple a = apples.get(index.decrementAndGet());
            System.out.println(Thread.currentThread().getName() + "消费了: " + a.id);
            return a;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return null;
    }
}


class Producer implements Runnable {
    AppleBox appleBox;

    public Producer(AppleBox appleBox) {
        this.appleBox = appleBox;
    }

    @Override
    public void run() {
        while (true) {
            appleBox.deposite(new Apple(appleBox.index.get() + 1));
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    AppleBox appleBox;

    public Consumer(AppleBox appleBox) {
        this.appleBox = appleBox;
    }

    @Override
    public void run() {
        while (true) {
            try {
                appleBox.withdraw();
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                Thread.sleep((int) (Math.random() * 3000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
xrl66
关注
专栏目录
Java并发编程-AQS详解及案例实战（上篇）
program哲学
07-06 221
详细介绍AQS底层机制及相关应用案例实战
深入理解Java并发编程之Lock和AQS
u011452172的博客
06-12 362
本文主要为《Java并发编程的艺术》第三章的读书记录笔记 Lock接口 Lock vs synchronized Java SE 5之后，并发包中新增了Lock接口(以及相关实现类)用来实现锁功能，它提供了与synchronized关键字类似的同步功能。但是，它们却有以下不同： synchronized：使用synchronized的关键字将会隐式地获取和释放锁。同时，使用什么类型的锁(偏向，轻量级锁，重量级锁)以及锁的具体实现都是由JVM底层实现。 Lock接口：Lock接口相关实现类对于锁的获
AQS与LOCK
shiniannian的博客
03-30 136
详解JUC之锁——Lock与AQS（02）
腹黑大壁花
05-11 1689
前言在详解JUC之锁——概述（01）中我对JUC中的锁进行了概述，下面我就介绍一下它们的根基Lock接口和AQS类Lock看名字就知道Lock接口就是JUC中锁的顶级接口，支持语义不同的锁规则，比如说公平锁和非公平锁，独占锁（也可以叫互斥锁）和共享锁等。它最主要的两个方法就是lock()和unlock()，一看就知道是获取锁和释放锁。还有一个比较有趣的方法是boolean tryLock(long
Lock 和 AQS
WYSCODER的博客
05-14 527
文章目录Lock 和 AQSLock接口AQSAQS同步器原理 Lock 和 AQS Lock接口 Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition。 Lock接口提供的方法操作： void lock() 获取锁，如果锁被使用会一直阻塞直至获取到锁。 void lockInterruptibly() throws InterruptedException 如果当前线程
AQS及Lock锁详解
Lizhj的博客
08-08 1513
目录 AQS 概念 类图 Node节点分析 特点 主要方法 Lock继承关系 公平锁和非公平锁 公平锁 非公平锁 ReentrantLock 构造函数 加锁过程 解锁过程 可重入性 可打断原理 不可打断 可打断模式 公平锁/非公平锁实现 条件队列 await流程 signal流程 ReentrantReadWriteLock 背景 规则 使用示例 读写锁升降级 原理分析 先写后读 再读再写 小结 Lock锁与Synchronized对比 A.
04-并发编程面试题-重点.docx
08-22
涵盖了并发编程的优缺点、多线程、线程安全、线程同步、线程调度、线程通信、锁机制、volatile 关键字、Lock 机制、CAS 机制、死锁、饥饿、锁升级等概念，旨在帮助读者更好地理解并发编程的基础知识和高级知识。...
java并发编程-AQS和JUC实战
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
Java并发编程面试题（2024最新版）-重点.docx
最新发布
05-23
### Java并发编程面试题知识点详解 #### 一、基础知识与概念 **1. 并发编程的优缺点：** - **优点：** - **提高性能：**通过多个任务同时执行，可以有效利用多核处理器资源，提升整体系统的吞吐量。 - **响应性：...
20.9.24aqs-并发编程笔记.pdf
04-28
这种模式主要解决了在并发编程中如何安全高效地进行线程间通信和数据传递的问题。 该模式的基本概念包含以下几个方面： 1. 线程间传递结果：在多线程编程中，某个线程处理的结果需要传递给其他线程。这种传递通常...
深入理解Java中的Lock和AQS
FBB360JAVA的博客
06-25 554
提起Java中的锁，一般我们最快的反应是。但是在Java1.5之后，Doug Lea 大姥设计并实现的 JUC 中，提供了更加丰富的API操作。其中Lock接口及其相关实现尤为经典。今天我们来一起学习这 JUC 中的优秀设计思想。与有锁不同，Lock接口及其实现是由Java代码实现的。其底层代码实现，基于抽象队列同步器（）以及volatile关键字、CAS机制。以下内容分析，代码参考于Java11。因为Lock本身是一个接口，所以我们在用的时候，基本都是找它的实现。
【小明】谈谈你对Lock和AQS的理解【建议收藏】
小明的Java问道之路
09-13 830
一、直接开始谈Lock 【简单谈一下 Lock使用，实现类源码和原理，点到为止（在说完AQS时可以回过头谈一谈 ReentrantReadWriteLock 原理或者自己设计一个锁或者AQS怎么做），抛出JDK8中新的优化类，证明咱技术还可以，快速过，暂时重点放在后面 AQS 上面】 Lock是JDK提供给我们的显示锁，一般我们在try块前使用 lock() 方法获取锁，finally 块中调用unlock() 释放锁，通常除了获取释放，我们还使用 lockInterruptibly() 可中断地获取锁
Lock锁详解（AQS,独占锁，可中断式获取锁，超时获取锁，理解ReentrantLock、ReentrantReadWriteLock，Condition的await、signal）
zhao_miao的博客
05-07 1762
文章目录1.Lock与AbstractQueuedSynchronizer1.1 Lock简介1.2 Lock接口中的API1.3 AQS同步器AQS使用模板设计模式自己实现一个简易的Lock锁2. 独占锁2.1 独占锁的获取 1.Lock与AbstractQueuedSynchronizer 1.1 Lock简介 锁 能够防止多个线程同时访问共享资源 在Lock接口出现之前，Java程序主要是靠...
Lock锁之公平锁与非公平锁(AQS实现原理)
Fighting_Man的博客
10-22 4171
在Concurrent包中的锁都是可重入锁，一般都命名为ReentrantX。可重入锁是指当一个线程调用object.lock拿到锁，进入互斥区后，再次调用object.lock，仍然可以拿到该锁。 synchtonized关键字就是可重入锁。
Java并发-AQS及各种Lock锁的原理
热门推荐
不瘦十斤不换名字
04-18 3万+
什么是AQS AQS是AbustactQueuedSynchronizer的简称，它是一个Java提高的底层同步工具类，用一个int类型的变量表示同步状态，并提供了一系列的CAS操作来管理这个同步状态。AQS的主要作用是为Java中的并发同步组件提供统一的底层支持，例如ReentrantLock，CountdowLatch就是基于AQS实现的，用法是通过继承AQS实现其模版方法，然后将子类作为同...
JAVA中AQS详解
落叶飘零z的博客
05-05 986
ReentrantLock、ReentrantReadWriteLock底层都是基于AQS来实现的。 那么AQS的全称是什么呢？AbstractQueuedSynchronizer，抽象队列同步器。ReentrantLock内部包含了一个AQS对象，也就是 AbstractQueuedSynchronizer类型的对象。这个AQS对象就是ReentrantLock可以实现加锁和释放锁的关键性的...
通俗理解AQS原理及与Reentrantlock的关系
Lynn_coder的博客
10-13 946
面试时候一个很常见的问题，就是AQS的理解，往往问到Reentrantlock之后，面试官会问，你知道Reentrantlock的实现吗？ Reentrantlock Reentrantlock翻译过来就是可重入锁，通俗的讲，就是如果一个线程获取到了这个锁，他可以再次获取。但是释放的时候，如果获取了10次，也需要释放10次才能完全释放完毕 也就是说，这里lock 10次，需要unlock...
Java---Lock锁（AQS与Lock区别)
sophia__yu的博客
11-21 2966
什么是Lock锁？ 在Java中锁是出现是为了防止多个线程访问同一资源，锁有内建锁（synchronized）,synchronized关键字实现锁是隐式加解锁，在JDK5后，java.util.concurrent包中增加了lock接口，它提供了和synchronized一样可以防止多个线程访问同一资源，但是lock锁需要手动加锁解锁，也提供了synchronized没有的同步特性（后文会叙述）...
深入剖析Lock与AQS
南国的技术栈
12-20 406
1. JUC的基本结构 Java开发人员中，我们一般把java.util.concurrent简称为JUC包，泛指我们日常用到的并发多线程中的知识模块。下图是concurrent包的目录结构图。 其中包含了两个子包：atomic以及lock，另外在concurrent下的阻塞队列以及executors,这些就是concurrent包中的精华。从整体上来看concurrent包的整体实现图如下图所...
Java并发编程Synchronized&Lock&AQS深入解析
Java作为一种广泛使用的编程语言，提供了强大的并发编程支持，这包括关键字synchronized、java.util.concurrent.locks包下的Lock接口、以及抽象同步队列（AbstractQueuedSynchronizer，简称AQS）等机制。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值