线程并发学习----JUC工具类

线程并发学习—-核心概念（转载）
线程并发学习—-线程阻塞（sleep、wait、notifyAll、notify、join）
线程并发学习—-线程阻塞（synchronized）
线程并发学习—-线程阻塞（lock）
线程并发学习—-Thread、Runnable、Callable
线程并发学习—-队列（Queue）
线程并发学习—-JUC工具类
spring学习—-线程池
java中一些锁概念整理（转载）

简介

常用工具类CountDownLatch、CyclicBarrier、Semaphore；

• CountDownLatch通过AQS实现
• CyclicBarrier通过ReentrantLock
• Semaphore实现原理与ReentrantLock类似，通过内部类Sync、NonfairSync、FairSync，不过其是对一组资源的限制

分析

• CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：
• CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；
• 而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

• 另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

• Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。

CountDownLatch

方法

• await() 调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
• await(long timeout, TimeUnit unit) 和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
• countDown() 将count值减1

源码

public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

分析

从上面代码可以看出，CountDownLatch初始化设置一个state值（等待线程数），调用await方法判断state是否为0，如果是0，不阻塞，否则进入等待队列阻塞；每次调用countDown方法将state减1

示例

public class CountDownLatchDemo {

    public static void main(String[] args) {

        final CountDownLatch latch = new CountDownLatch(1);

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                    Thread.sleep(1000);
                    System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        try {
            System.out.println("等待1个子线程执行完毕...");
            latch.await();
            System.out.println("1个子线程已经执行完毕");
            System.out.println("继续执行主线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

CyclicBarrier

方法

await() 调用后线程就处于barrier了，等待一组线程都到达barrier后全部同时执行

源码

private final ReentrantLock lock = new ReentrantLock();

分析

从上可以看出CyclicBarrier通过ReentrantLock实现

Semaphore

方法

阻塞

• acquire() 获取一个许可
• acquire(int permits) 获取permits个许可
• release() 释放一个许可
• release(int permits) 释放permits个许可

非阻塞

• tryAcquire() 尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
• tryAcquire(long timeout, TimeUnit
  unit)尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
• tryAcquire(int permits)
  尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
• tryAcquire(int permits, long timeout, TimeUnit unit)
  尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

分析

从代码可以看出，Semaphore与ReentrantLock实现非常相似，区别在于Semaphore初始化的时候是可以锁定一组资源

参考资料
https://www.cnblogs.com/dolphin0520/p/3920397.html