java并发工具类

---

title : 每日深耕，勤练不缀之java并发工具类

带你走进并发的世界
回顾：我们在IO中讲的用线程池，只是相对于几百访问量的并发，那些只是我们练习时的Demo，
我们通常所说的并发包就是java.util.concurrent及其子包，集中了Java并发的各种基础工具类：

• 提供了比synchronized更加高级的各种同步结构，包括CountDownLatch、CyclicBarrier、Semaphore等，可以更加丰富的多线程操作。

• 线程安全的容器 ConcurrentHashMap,无序，且MAP放入或者获取的速度更快；有序的ConcurrentSkipListMap,获取并不快，但是有助于增删查改；快照机制，动态数组CopyOnWriteArrayList
• 并发队列结构：BlockingQueue实现，如：ArrayBlockingQueue、SynchronousQueue或者针对场景的PriorityBlockingQueue
• 强大的Executor框架，可以创建不同类型的线程池，调度任务运行。不需要自己从头实现线程池和任务调度器

代码

package Bingfa;

import java.util.concurrent.Semaphore;



/**
 * 优秀的同步结构 CountDownLatch、CyclicBarrier、Semaphore
 * 线程安全的容器 ConcurrentHashMap,无序，且MAP放入或者获取的速度更快；有序的ConcurrentSkipListMap,获取并不快，但是有助于增删查改；快照机制，动态数组CopyOnWriteArrayList
 * 并发队列结构：BlockingQueue实现，如：ArrayBlockingQueue、SynchronousQueue或者针对场景的PriorityBlockingQueue
 * 强大的Executor框架，可以创建不同类型的线程池，调度任务运行。不需要自己从头实现线程池和任务调度器
 */
public class UsualSemaphoreSample {
    /**
     * Semaphore是经典信号量，它通过一定数量的允许（permit）的方式，达到限制通用资源访问的目的，有出租车空闲，防止
     * 拥挤，调度员允许一次只有五个访问，这个坐满下次访问再来
     * @param args
     */
    public static void main(String[] args) throws InterruptedException{
        System.out.println("Action..GO!");
        Semaphore semaphore =new Semaphore(5);
        for(int i=1 ;i<10;i++){
            Thread t=new Thread(new SemaphoreWorker(semaphore));
            t.start();
        }
    }

}
  class SemaphoreWorker  implements Runnable {
      /**
       *不能放入同一类里，这个就像调度员的角色
       * acquire的意思：可以将acquire操作视为是消费一个许可，而release操作是创建一个许可
       */
    private String name;
    private Semaphore semaphore;

    public SemaphoreWorker(Semaphore semaphore){//构造方法设定
        this.semaphore =semaphore;//this自引用
    }

      @Override
      public void run() {
        try{
            log("is waiting for a permit!");
            semaphore.acquire();
            log("acquired a permit");
            log("executed!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            log("released a permit");
            semaphore.release();

        }

      }//只是调用了两个方法，这就是利用semaphore,里面原理依旧是黑匣子
      private  void log(String msg){
        if(name==null){
            name=Thread.currentThread().getName();
        }
          System.out.println(name+" "+msg);
      }
  }

package Bingfa;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchSample {
    /**
     * countDown/await控制，调用await的线程阻塞等待countDown足够的次数，不管是一个或多个线程中，只要次数足够即可
     * 相对于semaphore, countDown不能重用,如果要支持更多人排队，就不能依赖一个countDownLatch
     * 就相当于我有限量的出租车，而你有无限量的人，等我拉完一趟你们的去另个地点再坐
     * 而semaphore相当于我有限量的指令，你们用完一个给我放一个，应该也不会超出。
     */
    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 for first batch finish");
        latch.countDown();
    }
}
class FirstBatchWorker implements Runnable{
    private CountDownLatch latch;
    public FirstBatchWorker(CountDownLatch latch){//每次都有一个构造函数
        this.latch =latch;
    }

    @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() {//其实就相当于数着await次数一样，满足countDown足够的次数，然后second才能运行
        try {
            latch.await();
            System.out.println("Second batch executed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package Bingfa;


import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierSample {
    /** 线程并行时候的协调，从逻辑上讲，五个工作线程就像代表了五个可以就绪的空车
     * 而不是五个待坐的乘客
     * 一种辅助性的同步结构，允许多个线程等待到达某个屏障，支持更多排队人数
     */
    public static void main(String[] args) {//到达5就是到达一个屏障
        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();
        }
    }
    static class CyclicWorker implements Runnable{
        private CyclicBarrier barrier;
        public CyclicWorker(CyclicBarrier barrier){//构造函数
            this.barrier =barrier;
        }

        @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();
            }

        }
    }
}

理解！！！