java多线程JUC常用辅助类详解

1.countdownlatch

减法计数器：实现调用几次线程后，在触发另一个任务

简单代码实现：

举例说明：就像五个人在同一房间里，有一个看门的大爷，当五个人都出去后，他才能锁门，也就是说 执行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.cyclicbarrier

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

简单代码实现：

举例说明：这里只要集齐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.semaphore

简单代码实现：
举例说明：抢车位 ，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();
        }
    }
}

运行结果：

原理说明：

semaphore.acquire() ; 获得，假设如果已经满了，等待，等待被释放为止！
semaphore.release() ; 释放，会将当前的信号量释放 + 1，然后唤醒等待的线程！

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

以上就是java多线程juc常用辅助类详解的详细内容，更多关于java多线程juc辅助类的资料请关注其它相关文章！