快手免费刷双击点赞 - 抖音点赞1元100赞,快手买赞自助平台

自助下单地址（拼多多砍价，ks/qq/dy赞等业务）：点我进入

1.倒计时锁存器

减法计数器：调用多个线程后，触发另一个任务

简单代码实现：

举个例子：像五个人一个房间，有一个看门的叔叔。 五个人全部出去之后，他才能锁门。 也就是说，出门动作的线程执行了5次才开始锁门。 这个动作

import java.util.concurrent.CountDownLatch;
/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-24 16:55
 **/
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        System.out.println("door is open");
        for (int i = 1; i <= 5 ; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+" is going out");
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("door is closed");
    }
}

代码运行结果：

基本的：

countDownLatch.countDown(); // 1号

countDownLatch.await(); // 等待计数器归零抢车位辅助器，然后往下执行

线程每次调用countDown()数-1，假设计数器变为0，countDownLatch.await()就会被唤醒继续执行！

2.循环障碍

这里我们简单理解为加法计数器

简单代码实现：

例如：这里只要收集到7颗龙珠，就会执行打印“收集到7颗龙珠”的线程。 这里我们先设置线程数为8抢车位辅助器，看打印的线程是否会被执行，然后执行数为7。

1、当cyclicBarrier的计数为8，执行线程数为7时：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-24 17:31
 **/
public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(8,new myThread());

        for (int i = 1; i <= 7 ; 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();
        }
    }
}
class myThread implements Runnable{
    @Override
    public void run() {
        System.out.println("7颗龙珠集齐啦");
    }
}

结果：

2、当cyclicBarrier的计数为1，执行线程数为7时：

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;
/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-24 17:31
 **/
public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,new myThread());
        for (int i = 1; i <= 7 ; 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();
        }
    }
}
class myThread implements Runnable{
    @Override

    public void run() {
        System.out.println("7颗龙珠集齐啦");
    }
}

结果：

看得到

  CyclicBarrier cyclicBarrier = new CyclicBarrier(7,new myThread());

执行完7个线程后，会执行一个实现了Runnable接口的线程

3.信号量

简单代码实现：

例如：抢一个车位，6辆车，最多三辆车同时进入

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-24 18:26
 **/
public class SemaphoreTest {

    public static void main(String[] args)  {
        //线程数量 ，停车位，,6辆车在等，最多只能同时进来三个 限流
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6 ; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();//获得
                    System.out.println(Thread.currentThread().getName()+"抢到车位了");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName()+"离开车位了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); //释放
                }
            },String.valueOf(i)).start();
        }
    }
}

运行结果：

原理说明：

信号量.acquire() ; 获取，如果满了就假设，等待，等到释放！

信号量.release() ; Release，会释放当前信号量+1，然后唤醒等待线程！

功能：多个共享资源的互斥使用！ 并发限流，控制最大线程数！

以上就是java多线程JUC常用辅助类详解详解的详细内容。 更多java多线程JUC辅助类请关注云海天教程其他相关文章！