JUC常用辅助类及读写锁

JUC常用辅助类*

(1).CountDownLatch

手动减

/**
 * CountDownLatch减法计数器
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);//设定计数器原始值
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"->");
                countDownLatch.countDown();//计数器做减法
            },i+"").start();
        }
        countDownLatch.await();//等待计数器为0后执行之后操作
        System.out.println("归零");
    }
}

0->
2->
3->
1->
4->
5->
归零

(2).CyclicBarrier

自动加

/**
 * CyclicBarrierTest加法计数器
 */
public class CyclicBarrierTest {
    public static void main(String[] args) {
        //需要达到的已执行线程数    达到后执行的指定线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("达到了");
        });
        for (int i = 1; i < 10; i++) {
            final int a = i; //λ表达式是取不到这个i的
            new Thread(()->{
                System.out.println("->"+a);
                //执行计数器等待 每次执行一个线程 自动 加
                try {
                    cyclicBarrier.await();//等待达到
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

->2
->6
->5
->4
->3
->1
->9
达到了
->8
->7

(3).Semaphore

信号量(可同时执行量)

public class SemaphoreTest {
    public static void main(String[] args) {
        //指定由几个位置(几个可同时执行的线程)
        Semaphore semaphore = new Semaphore(2);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();//让这个线程得到一个位置
                    System.out.println(Thread.currentThread().getName()+"在执行");
                    TimeUnit.SECONDS.sleep(3);//模拟线程执行3秒
                    System.out.println(Thread.currentThread().getName()+"在执行完毕");
                    semaphore.release();//释放当前位置 唤醒其他线程并给予位置
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },i+"").start();
        }
    }
}

1在执行
2在执行   //3s
1执行完毕
2执行完毕
4在执行
3在执行   //3s
4执行完毕
3执行完毕
5在执行
6在执行   //3s
6执行完毕
5执行完毕

使用场景:多个资源互斥 并发限流,控制最大线程数

读写锁

ReadWriteLock -实现类-> ReentrantReadWriteLock

多个线程 同时可读 但 只能单线程 单线写入

应用场景: 写入时只能由一条线程写入 且不能被读取 , 读取时随意

public class ReadWriteLockTest {
    public static void main(String[] args) {
        MyRw myRw = new MyRw();
        //执行写
        for (int i = 0; i < 10; i++) {
            final int ii = i;
            new Thread(()->{myRw.writeM(ii+"","写入的内容"+ii);},ii+"").start();
        }
        //执行读
        for (int i = 0; i < 10; i++) {
            final int ii = i;
            new Thread(()->{myRw.readM(ii+"");},ii+"").start();
        }
    }
}
/**
 * 读写方法
 */
class MyRw{
    private volatile Map<String,Object> map = new HashMap<>();
    //获取读写锁 使用方式基本和 lock相似
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    /**
     * 写入方法
     * @param key
     * @param value
     */
    public void writeM(String key,String value){
        readWriteLock.writeLock().lock();//加写锁 
        try {//业务
            System.out.println(key+"写入中");
            map.put(key,value);
            System.out.println(key+"写入成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();//解锁
        }
    }

    /**
     * 读取方法
     * @param key
     */
    public void readM(String key){
        readWriteLock.readLock().lock();//加读锁
        try {//业务
            System.out.println(key+"读取中");
            System.out.println(map.get(key));
            System.out.println(key+"读取成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();//解锁
        }
    }

}

0写入中
0写入成功
3写入中
3写入成功
8写入中
8写入成功
2写入中
2写入成功
1写入中
1写入成功
5写入中
5写入成功
7写入中
7写入成功
6写入中
6写入成功
4写入中
4写入成功
9写入中
9写入成功
2读取中
0读取中
写入的内容0
0读取成功
6读取中
写入的内容6
6读取成功
4读取中
写入的内容4
4读取成功
写入的内容2
2读取成功
9读取中
8读取中
写入的内容8
8读取成功
5读取中
写入的内容5
5读取成功
7读取中
写入的内容7
7读取成功
1读取中
写入的内容1
1读取成功
3读取中
写入的内容9
9读取成功
写入的内容3
3读取成功

可见: 读时多个线程同时 写入时仅能有一个 读-读-可同时执行 读-写-不可同时执行 写-写-不可同时执行

读锁=共享锁 独占锁=写锁