多线程三辅助工具类

---

CountDownLatch

减法计数器

允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助类

测试程序

		//必须要执行任务的时候再使用
        CountDownLatch countDownLatch=new CountDownLatch(6);//总数是6

        for(int i=0;i<6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                countDownLatch.countDown();
            },"Thread-"+i).start();
        }

        countDownLatch.await();//等待计数器归零，再向下执行

        System.out.println("done");

结果是

Thread-1
Thread-4
Thread-5
Thread-3
Thread-0
Thread-2
done

当线程数大于计数器的计数

	CountDownLatch countDownLatch=new CountDownLatch(2);//总数是2

        for(int i=0;i<7;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                countDownLatch.countDown();
            },"Thread-"+i).start();
        }

        countDownLatch.await();//等待计数器归零，再向下执行

        System.out.println("done");

有一次结果为

Thread-0
Thread-3
Thread-1
Thread-2
Thread-4
done
Thread-6
Thread-5

原理：

countDownLatch.countDown();//数量减一
countDownLatch.await();//等待计数器归零，然后向下执行

CyclicBarrier

加法计数器

测试

		CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功");
        });

        for(int i=1;i<=7;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                try {
                    cyclicBarrier.await();//没有达到计数器要求的数量会进入等待，计数器计数加一
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },"Thread-"+i).start();
        }

结果

Thread-1
Thread-4
Thread-3
Thread-2
Thread-6
Thread-5
Thread-7
召唤神龙成功

当计数器无法达到要求的数量，程序一直等待，当不会影响下面的程序运行

		CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功");
        });

        for(int i=1;i<=7;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                try {
                    cyclicBarrier.await();//没有达到计数器要求的数量会进入等待，计数器计数加一				
                    sout(3);//但是计数器等待会影响当前线程await方法下面的程序
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },"Thread-"+i).start();
        }
		sout(2);//不受计数器等待的影响

Semaphore

计数信号量

		//在限流中使用的多
		//允许同时执行的线程数量
        Semaphore semaphore=new Semaphore(3);

        for(int i=0;i<6;i++){
            new Thread(()->{
                try {
                    semaphore.acquire();//得到,直到有资源为止
                    System.out.println(Thread.currentThread().getName()+":start:"+semaphore.availablePermits());//剩余可用的
                } catch (InterruptedException e) {
                } finally {
                    System.out.println(Thread.currentThread().getName()+":end:"+semaphore.availablePermits());
                    semaphore.release();//释放
                }
            },"Thread-"+i).start();
        }

Thread-0:start:1
Thread-0:end:0
Thread-1:start:0
Thread-2:start:1
Thread-1:end:1
Thread-4:start:0
Thread-2:end:0
Thread-4:end:0
Thread-3:start:0
Thread-3:end:2
Thread-5:start:2
Thread-5:end:2