广州番禺人才网官网_在线天堂おっさんとわたし_aso关键词排名优化是什么_百度推广价格表

部分转自：http://www.cnblogs.com/waterystone/p/4920797.html

又名 AQS 框架，位于 java.util.concurrent.locks 包内。用来构建锁和同步器的框架，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的 ReentrantLock，Semaphore 等。

AQS 核心思想是通过以下方式，建立一套线程阻塞等待以及被唤醒时锁分配的机制。

• 如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。
• 如果被请求的共享资源被占用，就将暂时获取不到锁的线程封装成一个结点，加入到一个虚拟的双向队列 CLH 中。

*CLH 不存在真实的队列，仅存在结点之间的关联关系。

AQS 负责维护：

1. 一个 volatile int 成员变量 state
2. 一个 FIFO 线程等待队列

成员变量 state 表示资源状态，通过 getState/setState 方法存取。

线程抢占资源时会通过 CAS 操作去尝试修改 state ，成功则获取锁成功，失败则进入等待队列等待被唤醒。

AQS 定义两种资源共享方式

• Exclusive（独占）

只有一个线程能执行，如 ReentrantLock。

state初始化为0，表示未锁定状态。加一后锁定。

• Share（共享）

多个线程可同时执行，如 Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 。

返回 state 负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。

同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：

同步类在实现时一般都将自定义同步器（sync）定义为内部类，供自己使用；而同步类自己（Mutex）则实现某个接口，对外服务。

使用者继承 AbstractQueuedSynchronizer 并重写指定的方法。（这些重写方法很简单，无非是对于共享资源 state 的获取和释放） 将 AQS 组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。

isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。 tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。 tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。 tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。 tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

class Mutex implements Lock, java.io.Serializable {// 自定义同步器private static class Sync extends AbstractQueuedSynchronizer {// 判断是否锁定状态protected boolean isHeldExclusively() {return getState() == 1;}// 尝试获取资源，立即返回。成功则返回true，否则false。public boolean tryAcquire(int acquires) {assert acquires == 1; // 这里限定只能为1个量if (compareAndSetState(0, 1)) {//state为0才设置为1，不可重入！setExclusiveOwnerThread(Thread.currentThread());//设置为当前线程独占资源return true;}return false;}// 尝试释放资源，立即返回。成功则为true，否则false。protected boolean tryRelease(int releases) {assert releases == 1; // 限定为1个量if (getState() == 0)//既然来释放，那肯定就是已占有状态了。只是为了保险，多层判断！throw new IllegalMonitorStateException();setExclusiveOwnerThread(null);setState(0);//释放资源，放弃占有状态return true;}}// 真正同步类的实现都依赖继承于AQS的自定义同步器！private final Sync sync = new Sync();//lock<-->acquire。两者语义一样：获取资源，即便等待，直到成功才返回。public void lock() {sync.acquire(1);}//tryLock<-->tryAcquire。两者语义一样：尝试获取资源，要求立即返回。成功则为true，失败则为false。public boolean tryLock() {return sync.tryAcquire(1);}//unlock<-->release。两者语文一样：释放资源。public void unlock() {sync.release(1);}//锁是否占有状态public boolean isLocked() {return sync.isHeldExclusively();}
}Copy to clipboardErrorCopied

Java 的并发包提供了读写锁 ReentrantReadWriteLock ，其拥有两个锁：读锁-共享锁；写锁-排他锁。如果其他线程没有持有写锁，线程就能获得读锁。而只有其他线程没有持有任何锁，线程才能获得写锁。这样在没有写操作的时候，允许多个线程同时读一个资源，提高并发效率。

一个线程要想同时持有写锁和读锁，必须先获取写锁再获取读锁；写锁可以降级为读锁；读锁不能升级为写锁。

Semaphore 类是一个同步工具类，需要进行导入：import java.util.concurrent.Semaphore。

synchronized 和 ReentrantLock 一次只允许一个线程访问某个资源，如果指定多个线程同时访问某个资源需要钱使用 Semaphore 类。线程执行时调用 acquire 方法申请信号量，如果剩余信号量不足则必须等待其他线程执行完毕后调用 release 方法释放信号量。

Semaphore 方法

Semaphore semaphore = new Semaphore(0);       
Semaphore semaphore = new Semaphore(20, true);  // Semaphore 构造方法设定了初始信号量，可以为 0。默认为非公平锁，设定属性 true 则为公平锁。semaphore.acquire();              // 线程获取一个信号量
semaphore.acquire(5);             // 线程获取五个信号量semaphore.release();              // 线程释放一个信号量
semaphore.release(5);             // 线程释放五个信号量semaphore.availablePermits();     // 读取剩余信号量Copy to clipboardErrorCopied

Semaphore 示例

public class SemaphoreExample1 {public static void main(String[] args) throws InterruptedException {ExecutorService threadPool = Executors.newFixedThreadPool(300);// 设置 20 个信号量final Semaphore semaphore = new Semaphore(20);// final Semaphore semaphore = new Semaphore(20, true);  公平锁for (int i = 0; i < 500; i++) {final int threadnum = i;threadPool.execute(() -> {try {semaphore.acquire();             // 获取一个信号量test(threadnum);semaphore.release();             // 释放一个信号量} catch (InterruptedException e) {e.printStackTrace();}});}threadPool.shutdown();System.out.println("finish");}public static void test(int threadnum) throws InterruptedException {Thread.sleep(1000);System.out.println("threadnum:" + threadnum);Thread.sleep(1000);}
}Copy to clipboardErrorCopied

CountDownLatch 类是一个同步工具类，需要进行导入：import java.util.concurrent.CountDownLatch。

其通过 await 方法设置一个屏障，线程到达后被阻塞。直到其他线程调用 countDown 方法达到 N 次后才允许向后执行。 CountDownLatch 类是一次性的，计数器值只能在构造方法中初始化一次，不能被重复使用。常用来协同多个线程之间的执行顺序，比如主线程需要等待多个组件加载完毕之后再继续执行。

CountDownLatch 方法

CountDownLatch latch = new CountDownLatch(5);// CountDownLatch 构造方法设定了门闩个数。latch.countDown();                // 解锁门闩，门闩个数减一
latch.await();                    // 线程等待门闩，个数为 0 后向后执行Copy to clipboardErrorCopied

CountDownLatch 示例

import java.util.concurrent.CountDownLatch;public class ThreadDemo {final static CountDownLatch latch = new CountDownLatch(5);public static void main(String[] args) throws InterruptedException {for(int i = 0; i < 5; i++) {new MyThread().start();}latch.await();System.out.println("主线程继续执行");}static class MyThread extends Thread {@Overridepublic void run() {try {System.out.println(getName() + "打开门闩");} finally {latch.countDown();}}}
}Copy to clipboardErrorCopied

CyclicBarrier 类也是一个同步工具类，需要进行导入：import java.util.concurrent.CyclicBarrier。

其通过 await 方法设置一个屏障，线程到达后被阻塞。只有当 N 个线程都到达屏障后才允许这些线程向后执行。和 CountDownLatch 不同，CyclicBarrier 可循环利用。常用于多线程计算数据，最后合并计算结果的场景。

CyclicBarrier 方法

CyclicBarrier barrier = CyclicBarrier(10); 
CyclicBarrier barrier = CyclicBarrier(10, ()-> System.out.println("open"));// CyclicBarrier 构造方法设定了参与线程的个数 N，也可以选择设定在第 N 个线程到达屏障时执行方法。barrier.await();                             // 线程必须等到 N 个线程才能向后执行
barrier.await(20, TimeUnit.SECONDS);         // 线程等待规定时间后无论如何都会向后执行Copy to clipboardErrorCopied

CyclicBarrier 示例

import java.util.concurrent.CyclicBarrier;public class CyclicBarrierDemo {  public static void main(String[] args) {  for(int i = 0; i < 10; i++) {new MyThread().start();}} 
}class MyThread extends Thread {static CyclicBarrier barrier = new CyclicBarrier(5, new Runnable() {@Overridepublic void run() {System.out.println("栅栏开启");}});@Overridepublic void run() {try {Thread.sleep(1000);System.out.println(getName() + " 到达栅栏");barrier.await();System.out.println(getName() + " 冲破栅栏");} catch (Exception e) {e.printStackTrace();}}
}
) {try {Thread.sleep(1000);System.out.println(getName() + " 到达栅栏");barrier.await();System.out.println(getName() + " 冲破栅栏");} catch (Exception e) {e.printStackTrace();}}
}