Java 并发包提供了哪些并发工具类

Java 基础并发工具类

提供了比 synchronized更加高级的各种同步结构，包括 CountDownLatch, CyclicBarrier、 Semaphore等，可以实现更加丰富的多线程操作，比如利用 Semaphore作为资源
各种线程安全的容器，比如最常见的 ConcurrentHashMap、有序的 ConcunrrentskipListMap，或者通过类似快照机制，实现线程安全的动态数组 Copy onWriteArrayuist等
各种并发队列实现，如各种 BlockedQueue实现，比较典型的 ArrayBlockingQueue、 SynchorousQueue或针对特定场景的 Priority BlockingQueue等。
强大的 Executor框架，可以创建各种不同类型的线程池，调度任务运行等，绝大部分情况下，不再需要自己从头实现线程池和任务调度器。

多线程编程要注意哪些

利用多线程提高程序的扩展能力，以达到业务对吞吐量的要求。
协调线程间调度、交互，以完成业务逻辑。
线程间传递数据和状态，这同样是实现业务逻辑的需要。

并发包工具需要掌握哪些

从总体上，把握住几个主要组成部分
理解具体设计、实现和能力。
再深入掌握一些比较典型工具类的适用场景、用法甚至是原理，并熟练写岀典型的代码用例

CountDownLatch

允许一个或者多个线程等待操作完成

CountDownLatch 是不可以重置的，无法重用，但是 CyclicBarrier则没有这个限制，可以重用。
CountDownLatch 的基本操作时 countDown/await。调用await 线程阻塞等待 countDown 足够的次数，不管是在一个线程还是多个线程里 CountDown,只要次数足够即可。

假设有10个人排队,我们将其分成5个人一批，使用CountDownLatch 来协调。

public class LatchSample {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(6);
        for(int i = 0; i < 5 ; i++){
            Thread t = new Thread(new FirstBatchWorker(latch));
            t.start();
        }
        for(int i = 0 ; i < 5;i++){
            Thread t = new Thread(new SecondBatchWorker(latch));
            t.start(); 
        }
        while(latch.getCount() != 1){
            Thread.sleep(100L);
        }
        System.out.println(" wait gor first batch finish");
        latch.countDown();
    }

}

class FirstBatchWorker implements Runnable {
    private CountDownLatch latch;

    public FirstBatchWorker(CountDownLatch latch) {
        this.latch = latch;
    }

    /**
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        System.out.println("First batch executed!");
        latch.countDown();
    }
}

class SecondBatchWorker implements Runnable {
    private CountDownLatch latch;

    public SecondBatchWorker(CountDownLatch latch) {
            this.latch = latch;
    }

    @Override
    public void run() {
        try {
            latch.await();
            System.out.println("Second batch Executed!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

CountDownLatch调度也较为简单，后一批的线程进行 await 等待前一批 countdown 足够多次。局限性是不能重用

CyclicBarrier

允许多个线程瞪大到达某个屏障

CyclicBarrier的基本操作组合，则就是 await，当所有的伙伴（ parties）都调用了 await，才会继续进行任务，并自动进行重置。注意，正常情况下， CyclicBarrier的重置都是自动发生的，如果我们调用 reset 方法，但还有线程在等待，就会导致等待线程被打扰，抛出 BrokenBarrierException异常。 CyclicBarrier侧重点是线程，而不是调用事件，它的典型应用场景是用来等待并发线程结束

public class CyclicBarrierSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(5, new Runnable() {

            @Override
            public void run() {
                System.out.println("Action.... go again!");
            }
        });
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new CyclicWorker(barrier));
            t.start();
        }
    }
}

class CyclicWorker implements Runnable {

    private CyclicBarrier barrier;

    public CyclicWorker(CyclicBarrier barrier) {
        this.barrier = barrier;
    }

    /**
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {

        try {
            for (int i = 0; i < 3; i++) {
                System.out.println("Executed!");
                barrier.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }

    }
}

Semaphore

Java 版本信号量的实现，通过允许一定数量的允许（Permit）的方式，来表达限制通用资源访问的目的。
租车时，当很多空出租车就位时，为防止过度拥挤，调度员指挥排队等待坐车的队伍一次进来5个人上车，等这5个人坐车出发，再放进去下一批，这和 Semaphore的工作原理类似

线程尝试获得许可，获得许可则进入任务，任务执行完，然后释放许可。这时等待许可的其他线程，可以获得许可进入工作状态，知道全部处理结束。

public class SemaphoreSample {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("Action ...Go!");
        Semaphore semaphore = new Semaphore(5);
        for(int i = 0; i < 10;i++){
            Thread t = new Thread(new SemaphoreWorker(semaphore));
            t.start();
        }
    }

}

class SemaphoreWorker implements Runnable{
    private String name;
    private Semaphore semaphore;
    
    public SemaphoreWorker(Semaphore semaphore){
        this.semaphore = semaphore;
    }
    
    @Override
    public void run() {
        try {
            log("is waitting for permit");
            semaphore.acquire();
            log("acquired a permit");
            log("excuted");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally{
            log("releae a permit");
            semaphore.release();
        }
    }
    private void log(String msg){
        if(name == null){
            name = Thread.currentThread().getName();
        }
        System.out.println(name+", "+ msg);
    }
}

Semapore 类似计数器，实现逻辑基于 Acquire/release,如果 semaphore 的数值初始化成1 相当于互斥锁只有一个资源供竞争。

https://www.baeldung.com/java-phaser

线程安全的集合

线程安全Map ,List 和 Set。
当应用侧重 Map 存放的速度，推荐使用 ConcurrentHashMap, 如果需要使用大量数据进行频繁的修改，推荐使用 ConcurrentSkipListMap

SkipList

CopyOnWriteArrayList

CopyOnWriteArraySet 包装了 CopyOnWriteArrayList 来实现
CopyOnWrite 原理是任何修改操作，add,set remove 都会拷贝原数组，修改后替换原理的数组，通过这种防御方式，实现另类的线程安全。这种数据结构，适合读多写少的操作。

  public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

程序员开发者社区

微信公众号