juc的辅助类

countdownlatch

*　由尾开始计算
*　用一个程序计数器CountDownLatch，每执行完成一个线程，调用countDown()使计数器减一，主线程中使用countDownLatch的await()方法等待

使用程序计数器：

import java.util.concurrent.CountDownLatch;

public class JunitMultiThreadTest {
     
private int i = 5;
/*
* 线程计数器
* 将线程数量初始化
* 每执行完成一条线程，调用countDown()使计数器减1
* 主线程调用方法await()使其等待，当计数器为0时才被执行
*/
private CountDownLatch latch = new CountDownLatch(i);
@Test
public void test() throws InterruptedException {
     
    for (int i = 0; i < this.i; i ++) {
     
        new Thread(new Runner(),"JUNIT多线程测试").start();
    }
    try {
     
        latch.await(); // 主线程等待
    } catch (InterruptedException e) {
     
        e.printStackTrace();
    }
}
class Runner implements Runnable {
     
        @Override
        public void run() {
     
            System.out.println("【当前线程ID】:"+Thread.currentThread().getId());
            latch.countDown(); // 执行完毕，计数器减1
        }
    }
}

cyclicBarrier

• 由头开始计算
• 每开始一个线程 cyclicbarrier就加一，知道达到创建时所设定的线程，cyclicBarrier才开始执行内部的线程

public class CyclicBarrierDemo {
     
    public static void main(String[] args) {
     
        int count = 7;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(count, () -> System.out.println("已经执行了7个线程了"));

        for (int i = 0; i < count; i++) {
     
            int finalI = i;
            new Thread( () -> {
     
                System.out.println(Thread.currentThread().getName()+"第"+ finalI +"次");
                try {
     
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
     
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }

}

semaphore

在信号量上我们定义了两种操作：

• acquire（获取操作）当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减一），要么一直等待下去，直到有线程释放信号量
• release（释放操作）实际上会将信号量的值加1，然后唤醒等待的线程

目的：

• 用于多个共享资源的互斥作用
• 用于并发线程数的控制

    Semaphore semaphore = new Semaphore(3);
    for (int i = 0; i < 6; i++) {
     
        new Thread(() -> {
     
            try {
     
                //获取操作
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()+"----->抢到了车位");
                TimeUnit.SECONDS.sleep((long) (Math.random()*10));
                System.out.println(Thread.currentThread().getName()+"----->离开了车位");
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            } finally {
     
                //释放操作
                semaphore.release();
            }
        },String.valueOf(i)).start();
    }