读书笔记《JAVA并发编程的艺术》 第五章 Java中的锁 5.2 队列同步器 5.2.1

5.2 队列同步器

同步器(AbstractQueuedSynchronizer)是实现锁或者说任意同步组件的关键,在锁的实现中聚合同步器,利用同步器实现锁的语义。
同步器和锁的关系:锁是面向使用者的,它定义了使用者与锁交互的接口(比如可以允许两个线程并行访问),隐藏了实现细节;同步器面向的是锁的实现者,它简化了锁的实现方式,屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。

5.2.1 队列同步器的接口与示例

同步器的设计基于模板设计模式。

访问修改同步状态的方法:

  1. getState():获取当前同步状态
  2. setState(int newState):设置当前同步状态
  3. compareAndSetState(int except,int update): 使用CAS设置当前状态,该方法可以保证状态设置的原子性。

同步器可以重写的方法:

  1. boolean tryAcquire(int arg) : 独占式获取同步状态
  2. boolean tryRelease(int arg) : 独占式释放同步状态
  3. int tryAcquireShared(int arg) : 共享式获取同步状态,返回大于等于0的值意味成功
  4. boolean tryReleaseShared(int arg) : 共享式释放同步状态
  5. bolean isHeldExclusively(): 当前线程是否在独占模式下被线程占用,一般表示是否被当前线程所独占

同步器提供的模板方法:

  1. void acquire(int arg) : 独占式获取同步状态,如果当前线程获取同步状态成功,则返回,否则会进入同步队列等待,该方法将会调用重写的tryAcquire(int arg)方法
  2. void acquireInterruptibly(int arg) : 与上一个方法一样,但是该方法响应中断,如果当前线程未获取到同步状态则进入同步队列,如果当前线程被中断,则该方法会抛出InterruptedException并返回。
  3. boolean tryAcquireNanos(int arg,long nanos) : 在acquireInterruptibly(int arg)的基础上,增加了超时限制,如果当前线程在超时时间内获取到了同步状态,则返回true,反之,则返回false.
  4. void acquireShared(int arg): 共享式的获取同步状态,如果当前线程未获取到同步状态,则会进入同步队列中等待,与独占式的不同,可能在同一个时刻可以有多个线程获取到同步状态。
  5. void acquireSharedInterruptibly(int arg) : 与acquireShared相同,只是该方法响应中断
  6. boolean tryAcquireSharedNanos(int arg,long nanos):在上面方法的基础上,增加了超时控制
  7. boolean release(int arg):独占式的释放同步状态,该方法会在释放同步状态之后,将同步队列中的第一个节点包含的线程唤醒。
  8. boolean releaseShared(int arg):共享式的释放同步状态
  9. Collection< Thread > getQueuedThreads(): 获取等待在同步队列上的线程集合

上述方法大体分为三类:独占式获取与释放同步状态、共享式获取与释放同步状态、查询同步队列中的等待线程情况。

独占锁的示例代码:

public class Mutex implements Lock {
//静态内部类,自定义同步器
private static class Sync extends AbstractQueuedSynchronizer {
    //是否处于占用状态
    @Override
    protected boolean isHeldExclusively() {
        return getState() == 1;
    }

    //当状态为0时获取锁
    @Override
    public boolean tryAcquire(int acquires) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    //释放锁,将状态设置为0
    @Override
    protected boolean tryRelease(int releases) {
        if (getState() == 0) {
            throw new IllegalMonitorStateException();
        }
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    //返回一个Condition,每个Condition都包含了一个condition队列
    Condition newCondition() {
        return new ConditionObject();
    }
}

private final Sync sync = new Sync();

@Override
public void lock() {
    sync.acquire(1);
}

@Override
public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

@Override
public boolean tryLock() {
    return sync.tryAcquire(1);
}

@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(time));
}

@Override
public void unlock() {
    sync.release(1);
}

@Override
public Condition newCondition() {
    return sync.newCondition();
}

public boolean isLocked() {
    return sync.isHeldExclusively();
}

public boolean hasQueuedThreads() {
    return sync.hasQueuedThreads();
}
}
    原文作者:java锁
    原文地址: https://blog.csdn.net/maohoo/article/details/81357920
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞