【Java并发编程 九】JUC并发包下的锁

根据锁出现在Java中的时间,Java中的锁,可以分为同步锁JUC包中的锁,同步锁指的是通过synchronized关键字来进行同步,实现对竞争资源的互斥访问的锁,同步锁的原理是:

  • 对于每一个对象,有且仅有一个同步锁,不同的线程能共同访问该同步锁。
  • 在同一个时间点,该同步锁能且只能被一个线程获取到

这样,获取到同步锁的线程就能进行CPU调度,从而在CPU上执行;而没有获取到同步锁的线程,必须进行等待,直到获取到同步锁之后才能继续运行
在这里插入图片描述
相比同步锁,JUC包中的锁的功能更加强大,它为锁提供了一个框架,该框架允许更灵活地使用锁

接口

接口共有三个Lock接口、ReadWriteLock以及Condition接口。

Lock接口(范式)

JUC包中的 Lock 接口支持那些语义不同(重入、公平等)的锁规则。所谓语义不同,是指锁可是有公平机制的锁、非公平机制的锁、可重入的锁等等。

  • 公平机制是指"不同线程获取锁的机制是公平的,而非公平机制则是指"不同线程获取锁的机制是非公平的",这里的公平指的是如果公平,那么等待锁的多个线程将会按照申请锁的时间顺序来依次获得锁
  • 可重入的锁是指同一个锁能够被一个线程多次获取

它为实现自己的锁类提供了如下的一些方法:

void lock();
boolean tryLock();
void lockInterruptibly() throws InterruptedException;  //等待可中断
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;   //定时可中断
void unlock();
Condition newCondition();  //组合的方式获取Condition条件

ReadWriteLock接口

ReadWriteLock 接口以和Lock类似的方式定义了一些读取者可以共享而写入者独占的锁。JUC包只有一个类实现了该接口,即 ReentrantReadWriteLock,因为它适用于大部分的标准用法上下文。但程序员可以创建自己的、适用于非标准要求的实现。方法如下:

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

Condition接口

Condition需要和Lock联合使用,它的作用是代替Object监视器方法,可以通过await(),signal()来休眠/唤醒线程。Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似,但提供了更强大的功能。需要特别指出的是,单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题,Condition 方法的名称与对应的 Object 版本中的不同。

void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal();
void signalAll();

使用起来较为简单:

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
public void conditionWait() throws InterruptedException {
   lock.lock();
   try {
       condition.await();
 } finally {
       lock.unlock();
  }
}
public void conditionSignal() throws InterruptedException {
   lock.lock();
   try {
     condition.signal();
   } finally {
     lock.unlock();
   }
}

一般都会将Condition对象作为成员变量。当调用await()方法后,当前线程会释放锁并在此等待,而其他线程调用Condition对象的signal()方法,通知当前线程后,当前线程才从await()方法返回,并且在返回前已经获取了锁

抽象类

抽象类共有三个,AbstractOwnableSynchronizer,AbstractQueuedSynchronizer,AbstractQueuedLongSynchronizer三个抽象类

AQS抽象类(模版)

AbstractQueuedSynchronizer就是被称之为AQS的类,它是一个非常有用的超类,可用来定义锁以及依赖于排队阻塞线程的其他同步器,ReentrantLock,ReentrantReadWriteLock,CountDownLatch,CyclicBarrier和Semaphore等这些类都是基于AQS类实现的

AQS原理

AQS核⼼思想是,如果被请求的共享资源空闲,则将当前请求资源的线程设置为有效的⼯作线程,并且将共享资源设置为锁定状态。如果被请求的共享资源被占⽤,那么就需要⼀套线程阻塞等待以及被唤醒时锁分配的机制,这个机制AQS是⽤CLH队列锁实现的,即将暂时获取不到锁的线程加⼊到队列中
在这里插入图片描述
AQS使⽤⼀个int成员变量来表示同步状态,通过内置的FIFO队列来完成获取资源线程的排队⼯作。AQS使⽤CAS对该同步状态进⾏原⼦操作实现对其值的修改

 /**
     * The synchronization state.
     */
    private volatile int state;

    /**
     * Returns the current value of synchronization state.
     * This operation has memory semantics of a {@code volatile} read.
     * @return current state value
     */
    protected final int getState() {
        return state;
    }

    /**
     * Sets the value of synchronization state.
     * This operation has memory semantics of a {@code volatile} write.
     * @param newState the new state value
     */
    protected final void setState(int newState) {
        state = newState;
    }

    /**
     * Atomically sets synchronization state to the given updated
     * value if the current state value equals the expected value.
     * This operation has memory semantics of a {@code volatile} read
     * and write.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that the actual
     *         value was not equal to the expected value.
     */
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

AQS 对资源的共享⽅式

AQS定义两种资源共享⽅式

  • Exclusive(独占):只有⼀个线程能执⾏,如ReentrantLock。⼜可分为公平锁和⾮公平锁:公平锁:按照线程在队列中的排队顺序,先到者先拿到锁,⾮公平锁:当线程要获取锁时,⽆视队列顺序直接去抢锁,谁抢到就是谁的
  • Share(共享):多个线程可同时执⾏,如Semaphore、CountDownLatch、 CyclicBarrier等
  • ReentrantReadWriteLock 可以看成是组合式,因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某⼀资源进⾏读。

不同的⾃定义同步器争⽤共享资源的⽅式也不同。⾃定义同步器在实现时只需要实现共享资源 state的获取与释放⽅式即可,⾄于具体线程等待队列的维护(如获取资源失败⼊队/唤醒出队等),AQS已经在顶层实现好了。

AQS底层使用了模板方法模式

同步器的设计是基于模板⽅法模式的,如果需要⾃定义同步器⼀般的⽅式是这样(模板⽅法模式很经典的⼀个应⽤):

  1. 使⽤者继承AbstractQueuedSynchronizer并重写指定的⽅法。(这些重写⽅法很简单,⽆⾮是对于共享资源state的获取和释放)
  2. 将AQS组合在⾃定义同步组件的实现中,并调⽤其模板⽅法,⽽这些模板⽅法会调⽤使⽤者重写的⽅法。这和我们以往通过实现接⼝的⽅式有很⼤区别,这是模板⽅法模式很经典的⼀个运⽤。

AQS使⽤了模板⽅法模式,⾃定义同步器时需要重写下⾯⼏个AQS提供的模板⽅法:

isHeldExclusively()//该线程是否正在独占资源。只有⽤到condition才需要去实现它。
tryAcquire(int)//独占⽅式。尝试获取资源,成功则返回true,失败则返回false。
tryRelease(int)//独占⽅式。尝试释放资源,成功则返回true,失败则返回false。
tryAcquireShared(int)//共享⽅式。尝试获取资源。负数表示失败;0表示成功,但没有剩余可⽤资源;正数表示成功,且有剩余资源。
tryReleaseShared(int)//共享⽅式。尝试释放资源,成功则返回true,失败则返回false。

这些⽅法的实现必须是内部线程安全的,并且通常应该简短⽽不是阻塞。AQS类中的其他⽅法都是final ,所以⽆法被其他类使⽤,只有这⼏个⽅法可以被其他类使⽤,例如ReentrantLock实现一个非公平锁

  /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

非公平锁的底层实现调用并重写了tryAcquire

 static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

AQLS 抽象类

提供AQS相同的功能但扩展了对同步状态的 64 位的支持

AOS 抽象类

AQS还是AQLS两者都扩展了类 AbstractOwnableSynchronizer(一个帮助记录当前保持独占同步的线程的简单类)

    private transient Thread exclusiveOwnerThread;

    /**
     * Sets the thread that currently owns exclusive access.
     * A {@code null} argument indicates that no thread owns access.
     * This method does not otherwise impose any synchronization or
     * {@code volatile} field accesses.
     * @param thread the owner thread
     */
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    /**
     * Returns the thread last set by {@code setExclusiveOwnerThread},
     * or {@code null} if never set.  This method does not otherwise
     * impose any synchronization or {@code volatile} field accesses.
     * @return the owner thread
     */
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }

普通类

如果说Lock接口提供了锁的行为规范,AQS接口提供了锁的复杂实现,那么接下来的普通类就是使用时候的具体实现了。

LockSupport类

当需要阻塞或唤醒一个线程的时候,都会使用LockSupport工具类来完成相应工作,底层调用的是同步原语。LockSupport定义了一组的公共静态方法,这些方法提供了最基本的线程阻塞和唤醒功能,而LockSupport也成为构建同步组件的基础工具。

public static void park()  //阻塞
public static void unpark(Thread thread) //唤醒一个阻塞中的线程
public static void parkNanos(long nanos) //阻塞不超过nanos纳秒
public static void parkUntil(long deadline)  //最晚阻塞到时间点

ReentrantLock类

ReentrantLock是独占锁。所谓独占锁,是指只能被独自占领,即同一个时间点只能被一个线程锁获取到的锁互斥同步语义)。ReentrantLock锁包括公平的ReentrantLock非公平的ReentrantLock公平非公平语义)。ReentrantLock是可重入的锁可重入语义

  • ReentrantLock实现了Lock接口。
  • ReentrantLock中有一个成员变量sync,sync是Sync类型;Sync是一个抽象类,而且它继承于AQS。
  • ReentrantLock中有公平锁类FairSync和非公平锁类NonfairSync,它们都是Sync的子类。ReentrantReadWriteLock中sync对象,是FairSync与NonfairSync中的一种,这也意味着ReentrantLock是公平锁"或非公平锁中的一种,ReentrantLock默认是非公平锁。

是否公平依据构造函数决定

  /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

一般会将其与Synchronized进行比较

  • 两者默认都是非公平,悲观,独享,互斥,可重入锁
  • synchronized 依赖于 JVM ⽽ ReentrantLock 依赖于 API,不但可以通过一些监控工具监控synchronized的锁定,而且在代码执行时出现异常,JVM会自动释放锁定,但是使用Lock则不行,lock是通过代码实现的,要保证锁定一定会被释放,就必须将unLock放到finally{}中
  • ReentrantLock 拥有Synchronized相同的并发性和内存语义,此外还多了 可实现选择性通知(锁可以绑定多个条件),定时锁等候/等待可中断,可实现公平锁

需要注意,随着Synchronized的优化,性能已不能作为二者比较的标准

ReentrantReadWriteLock类

ReentrantReadWriteLock是读写锁接口ReadWriteLock的实现类,它包括内部类ReadLock和WriteLock。ReadLock是共享锁,而WriteLock是独占锁。

   /** Inner class providing readlock */
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** Inner class providing writelock */
    private final ReentrantReadWriteLock.WriteLock writerLock;
    /** Performs all synchronization mechanics */
    final Sync sync;

其继承结构为:

  • ReentrantReadWriteLock实现了ReadWriteLock接口。
  • ReentrantReadWriteLock中包含sync对象,读锁readerLock和写锁writerLock读锁ReadLock和写锁WriteLock都实现了Lock接口
  • 和ReentrantLock一样,sync是Sync类型;而且,Sync也是一个继承于AQS的抽象类。Sync也包括公平锁FairSync和非公平锁NonfairSync

其实和ReentrantLock类似,只不过ReentrantLock实现了它的一个独占版本。

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页
实付 19.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值