多线程基础（二）| 线程的优先级、CountDownLatch 和CyclicBarrier

最新推荐文章于 2023-03-05 15:03:50 发布
最新推荐文章于 2023-03-05 15:03:50 发布
阅读量224 收藏
点赞数 1
分类专栏： Java 多线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44978957/article/details/106055736
版权

多线程基础（二）| 线程的优先级、线程的生命周期及相关知识

1.线程优先级

线程优先级的设置和获取分别可以用setPriority()方法和getPriority()方法。

和优先级队列一样，每个线程有一个队行的优先级的数值来判断线程优先级的高低，取值范围为1~10，数字越大优先级越高，默认值为5。

理论上讲优先级高的先被执行。实际上，优先级高只是被cpu先执行概率大，并不是说优先级高的一定就会先被执行。因此我们在项目开发中不能使用优先级来完成一些特定的任务。

优先级的继承性

若B线程是在A线程中创建出来的，那么称B线程是A线程的子线程，这两个线程具有相同的优先级。

class ThreadA extends Thread {
    @Override
    public void run() {
        this.setPriority(1);
        System.out.println("A线程的优先级为：" + this.getPriority());
        ThreadB threadB = new ThreadB();
        threadB.start();
    }
}

class ThreadB extends Thread {
    @Override
    public void run() {
        System.out.println("B线程的优先级为：" + this.getPriority());
    }
}

public class TestApp {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        threadA.start();
    }
}

运行结果为：
在这里插入图片描述

优先级的特点：

  1. 线程优先级的继承特性:也就是如果线程A启动线程B,那么线程A和B的优先级是一样的；
  2. 线程优先级的规则性:即线程会优先级的大小顺序执行,但是不一定是优先级较大的先执行完,因为线程的优先级还有下面第三个特性：
  3. 线程优先级的随机特性优先级越高，大部分情况下在多个线程的情况下优先级高的先完成所有的任务。但是优先级并不是衡量那个线程运行结果顺序的标准，因为cpu只是尽量将执行资源交给优先级高的线程。优先级高的线程不一定每一次都先执行完run方法中的任务，也就是说线程优先级与打印顺序无关，他们的关系具有不确定性和随机性。

2.守护线程

守护线程是一个特殊的线程。它是一个在后台执行的线程，当所有非守护线程结束之后守护线程会自动结束。

如下面实例的程序，把子线程设置为守护线程，子线程的执行逻辑为一个死循环，一直打印子线程的名字。等到七秒之后，非守护线程主线程执行完成，子线程也自动结束，子线程的死循环结束。

public class DaemonTest {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName()); // 子线程一直打印
                }
            }
        });
        
        t.setDaemon(true); // 把子线程设置成守护线程 一定要在线程启动之前
        t.start();
        try {
            TimeUnit.SECONDS.sleep(7);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()); // 主线程名字
    }
}

守护线程的使用场景： 垃圾回收、服务器线程等。 垃圾是用户创建出来的线程产生的，当用户线程如果结束，就没有必要再去回收了。

3.线程的生命周期

线程的生命周期指的就是线程从生到死的过程。

我们知道，要开启一个线程，不管怎么样，都是要创建一个Thread对象的，那么线程的状态都是定义在Thread类下的，从源码中可以找到总共有New（新建）、Runnable（运行）、blocked（阻塞）、waiting、timed_waiting（等待）、terminated（终止）这几个状态。

线程的New状态：

  • 当我们用关键字new创建一个thread对象时，此时它并不是出于执行状态，因为没有调用start方法启动该线程，那么线程的状态为new状态。准确地说，它只是Thread对象的状态，因为没有start之前，该线程根部就不存在，与你用关键字new创建一个普通的java对象没有什么区别new状态通过start()方法进入runnable状态。

线程的Runnable状态：

  • Runnable状态：分成了两种状态，可执行（就绪态）和运行态。运行态顾名思义。就绪态指的是已经调用了start方法，但是线程还没有被cpu调度执行，只是具有了运行的资格。可执行（就绪态）的线程只能意外终止或者进入运行状态。

线程的blocked状态：

  • 线程阻塞状态。当程序进行某个阻塞的io操作，比如因网络数据的读写而进入的blocked状态，或获取某个锁资源，等待时，加入到该锁的阻塞队列中进入blocked状态。

线程的waiting状态：

  • 一个线程在等待执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后不能自动唤醒，必须等待另一个线程发出特定的指令才能够被唤醒。

线程的timed_waiting状态：

  • 和上面的类似，只是这个状态的线程不会一直等下去，会有一个超时时间。

线程的terminated状态

  • terminated是一个线程的最终状态，在该状态中线程将不会切换到其他任何状态，线程进入terminated状态，意味着该线程的整个生命周期结束了。

线程运行正常结束，结束生命周期，或线程运行出错意外结束。JVM crash会导致所有的线程都结束。

在这里插入图片描述
NEW、RUNNABLE、TERMINATED这三个状态时一个线程必定会经历的，其余几个状态只有当线程遇到某种状态或执行了某个方法才会经历。

4.线程join

调用join()方法可以让其他线程处于waiting状态。

如下面实例，我们分别在子线程调用join()方法前后获取一下主线程的状态

class JoinThread extends Thread {
    Thread thread;

    public JoinThread(String str, Thread thread) {
        super(str);
        this.thread = thread;
    }

    @Override
    public void run() { 

        for (int i = 0; i < 3; i++) {
            System.out.println(this.getName());
            System.out.println("state: " + thread.getState()); 
        }
    }
}

public class TestApp {
    public static void main(String[] args) {  //主线程
        JoinThread thread = new JoinThread("子线程",Thread.currentThread());
        thread.start(); //启动子线程
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主线程waiting  那么后面的代码在这段时间将不会被执行 直到调用join方法的这个线程执行完之后才会执行后续代码
        System.out.println("state: " + Thread.currentThread().getState());   //主线程被唤醒执行后的状态
        for (int i = 0; i < 4; i++) {
            System.out.println("主线程");
        }
    }
}

运行结果如图所示，可以看到，在调用了join()方法之后，主线程一直处于等待状态，直至子线程执行完毕：
在这里插入图片描述

若不调用join方法 ，那么子线程和主线程是同时在执行的，而不是如图先执行了子线程再执行了主线程。

通过实例，来看一下join()方法的应用场景，假设你负责一个旅游app的航班功能，分别推送三个航空公司的航班时间给用户。

我们可以启动三个线程，分别代表三家公司，主线程负责打印最后的结果，当三个子线程完成查询工作后，主线程才开始自己的功能执行。（为了方便，我们只设置8：00的航班）

我们可以让三个子线程分别调用join()方法，使主线程处于等待状态。代码如下：

class AirPlaneSearch implements Runnable {
    List<String> list;

    public AirPlaneSearch(List<String> list) {
        this.list = list;
    }

    @Override
    public void run() {   //查询各个航空公司的信息
        System.out.println("开始从" + Thread.currentThread().getName() + "查询航班信息");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (list) { // 加上线程锁 避免同时多个线程执行add操作
            list.add(Thread.currentThread().getName() + "8:00");
        }
    }
}

/**
 * 使用join方法
 */
public class AirLine {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        AirPlaneSearch runnable = new AirPlaneSearch(list);
        Thread t1 = new Thread(runnable, "南方航空");
        Thread t2 = new Thread(runnable, "东方航空");
        Thread t3 = new Thread(runnable, "海南航空");
        t1.start();
        t2.start();
        t3.start();
        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Iterator<String> iterator = list.iterator();
        System.out.println("--------------------------------------------");
        System.out.println("所查询的航班信息如下： ");
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

运行结果如下：
在这里插入图片描述在子线程的功能完成之后才输出list中的航班信息

5.CountDownLatch 和CyclicBarrier

用CountDownLatch可以避免写太多的join代码，先new出来一个CountDownLatch对象，将需要进行join操作的线程个数当作参数传递给构造函数，在子线程结束的时候对CountDownLatch进行减一操作，直至减为0后主线程开始执行它的功能。

还是以航班信息为例，代码如下：

class AirPlaneSearch2 implements Runnable {
    List<String> list;
    CountDownLatch latch ;

    public AirPlaneSearch2(List<String> list, CountDownLatch latch) {
        this.list = list;
        this.latch = latch;
    }

    @Override
    public void run() {   //查询各个航空公司的信息
        System.out.println("开始从" + Thread.currentThread().getName() + "查询航班信息");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (list) {
            list.add(Thread.currentThread().getName() + "8:00");
        }
        latch.countDown(); // count执行了一次减一
    }
}

/**
 * 使用CountDownLatch
 */
public class AirLine2 {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        CountDownLatch latch = new CountDownLatch(3); //有几个子线程就设置为几
        AirPlaneSearch2 runnable = new AirPlaneSearch2(list,latch);
        Thread t1 = new Thread(runnable, "南方航空");
        Thread t2 = new Thread(runnable, "东方航空");
        Thread t3 = new Thread(runnable, "海南航空");
        t1.start();
        t2.start();
        t3.start();
        try {
            latch.await();    //等待latch中的count被减为 0 什么时候减为 0 后面的代码才开始执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Iterator<String> iterator = list.iterator();
        System.out.println("--------------------------------------------");
        System.out.println("所查询的航班信息如下： ");
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

运行结果如下：
在这里插入图片描述
CyclicBarrier的参数和CountDownLatch差不多，按航班信息的例子来说，参数依然是3，不过CyclicBarrier不用使用方法进行减一操作，它会自动减一，直至0才开始执行中另一个参数Runnable()中的代码。

class AirPlaneSearch3 implements Runnable {
    List<String> list;
    CyclicBarrier barrier;

    public AirPlaneSearch3(List<String> list, CyclicBarrier barrier) {
        this.list = list;
        this.barrier = barrier;
    }

    @Override
    public void run() {   //查询各个航空公司的信息
        System.out.println("开始从" + Thread.currentThread().getName() + "查询航班信息");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (list) {
            list.add(Thread.currentThread().getName() + "8:00");
        }
        //遇到awit自动减一
        try {
            //所有的线程相互等待直到把barrier中的值减为0
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 使用CyclicBarrier
 */
public class AirLine3 {
    public static void main(String[] args) {
        final List<String> list = new LinkedList<>();
        // 什么时候barrier 减为0 Runnable中的方法被执行
        CyclicBarrier barrier = new CyclicBarrier(3, new Runnable(){
            @Override
            public void run() {
                Iterator<String> iterator = list.iterator();
                System.out.println("--------------------------------------------");
                System.out.println("所查询的航班信息如下： ");
                while (iterator.hasNext()){
                    System.out.println(iterator.next());
                }
            }
        });
        AirPlaneSearch3 runnable = new AirPlaneSearch3(list,barrier);
        Thread t1 = new Thread(runnable, "南方航空");
        Thread t2 = new Thread(runnable, "东方航空");
        Thread t3 = new Thread(runnable, "海南航空");
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果如下：
在这里插入图片描述
由代码可以看出来：由于使用起来并不灵活，一般CyclicBarrier在实际开发中并不常用。

6.线程中断

上面说到，调用join()方法的线程可以试别的线程进入等待状态，在开发中可能会遇到让线程的等待状态被打断的情况，调用interrupt()方法，可以中断一个线程的等待状态。

以下面实例来说，子线程调用join()方法后主线程进入等待状态，直到子线程打印操作结束后主线程才开始执行，而当第3次（由于cpu的调度，不一定正好三次）打印操作执行完后调用interrupt()方法，可以直接抛出异常，使得主线程的等待状态被打断。

class JoinThread extends Thread {
    Thread thread;
    private static int i = 0;

    public JoinThread(String str, Thread thread) {
        super(str);
        this.thread = thread;
    }

    @Override
    public void run() {
        while(true) {
            i++;
            System.out.println(this.getName());
            if (i == 3) {
                thread.interrupt();
            }
        }
    }
}

public class TestApp {
    public static void main(String[] args) {
        JoinThread thread = new JoinThread("子线程",Thread.currentThread());
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 4; i++) {
            System.out.println("主线程");
        }
    }
}

运行结果如下：
在这里插入图片描述

线程中断的方法：
Object的wait/wait (1ong) /wait (long, int)方法
Thread的sleep (int) /sleep (long, int)
Thread的join/join(long) /join(long, int)方法
 。。。。。。

为什么调用了interrupt方法就会让线程的waiting状态被打断？

答：调用了interrupt方法，会将线程中断位（interrupt
flag）由false变成true，而在join方法会判断线程中断位的状态，如果为true就会抛出异常，从而结束线程的等待状态。如果异常被捕获到，线程中断位的值就会再变成false（被擦除）。
获取线程中断位的方法可以通过实例方法this.isInterrupt()或静态方法Thread.interrupt()，两者的区别为后者再中断位被置为true后调用，线程中断位的值会被擦除，而前者不会主动擦除。

7.如何关闭一个线程

一个线程的结束再正常情况下即为一个线程的生命周期正常结束掉，通俗来说就是线程的run()方法从第一行代码执行到了最后一行。

还有一种非正常结束，当这个线程还在工作当中，但不希望它继续工作下去了，就要采取一些方式让他结束掉。

利用对线程中断位的值的控制可以做到对线程进行非正常的关闭

class SonThread implements Runnable {
    @Override
    public void run() {
        while(true) {
            if(Thread.currentThread().isInterrupted()){
                break;
            }
            System.out.println("子线程执行中");
        }
    }
}

public class TestApp {
    public static void main(String[] args) {
        SonThread runnable = new SonThread();
        Thread t = new Thread(runnable);
        t.start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
    }
}

当三秒之后调用interrupt，此时线程中断位置为false，子线程break出死循环，线程结束。

缺点：如果程序在其他地方调用了类似方法（如sleep、join等），那么中断位的值是会被擦除的，导致程序出现错误的几率变高。

捕获异常的方式同理：

class SonThread implements Runnable {
    @Override
    public void run() {
        while(true) {
            try {
                TimeUnit.NANOSECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break; // 捕获到异常之后要跳出循环
            }
            System.out.println("子线程执行中");
        }
    }
}

public class TestApp {
    public static void main(String[] args) {
        SonThread runnable = new SonThread();
        Thread t = new Thread(runnable);
        t.start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
    }
}

运行结果如下，三秒之后线程中断位值改变，抛出异常，结束线程：

在这里插入图片描述

抛出异常的处理方式的缺点：执行逻辑发生了改变 并且执行效率受到影响。

上面两种方式都有各自的缺点，在实际的项目开发当中并实用，有一种更好的处理方式，可以避免这两种情况的缺点。

我们给子线程提供一个静态变量flag，和一个关闭线程的静态方法。在run方法中定义：当flag的值变成true的时候break，在主线程处三秒后调用该静态方法使flag的值发生改变。

class SonThread implements Runnable {
    private static volatile boolean flag = false;

    public static void CloseThread() {
        flag = true;
    }

    @Override
    public void run() {
        while(true) {
            if (flag) {
                break;
            }
            System.out.println("子线程执行中");
        }
    }
}

public class TestApp {
    public static void main(String[] args) {
        SonThread runnable = new SonThread();
        Thread t = new Thread(runnable);
        t.start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        SonThread.CloseThread();
    }
}

这样既不会抛出异常，也不会出现值被擦除的现象。

关于volatile的线程安全问题将会在下一篇博客中讲解
菜鸡Chuki
关注
专栏目录
多线程设置优先级方法
zy901013的博客
05-10 1万+
之前看到个问题，如果有3个线程，如何保证3个线程的执行先后顺序。其实实现的方法有很多，这里主要介绍几种。 首先，线程Thread有一个设置优先级的属性Priority，默认数值为5，设置的越高优先级越高，最高为10。但是这里需要注意的是，优先级作用只是表示了执行的概率，也就是说优先级6的线程比5的线程概率更高，但不代表一定就有限执行。 （一）首先说下第一种方法，线程池ExecutorService...
Java多线程和并发基础面试题（问答形式）
09-02
Java多线程和并发基础面试题主要涵盖了一系列与Java中处理并发和多线程相关的核心概念和问题。以下是对这些知识点的详细解释： 1. **进程与线程的区别**： - **进程** 是操作系统资源分配的基本单位，拥有独立的...
多线程之CountDownLatch和CyclicBarrier
张育嘉的博客
08-30 545
一、倒计时CountDownLatch CountDownLatch是一个非常实用的多线程控制工具类，称之为“倒计时器”，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。 举了例子： 我们知道的集齐七颗龙珠就可以召唤神龙，那我们就一起召唤一下，下边我需要派7个人（7个线程）去分别去找这7颗不同的龙珠，每个人找到之后回来告诉我还需要等待的龙珠个数减1个，那么当全部的人都找到龙珠...
CountDownLatch多线线程使用，决定多线程执行顺序
mengtianqq的博客
01-19 695
CountDownLatch概念 CountDownLatch可以线程之间的通信（而不是用作互斥的作用）通俗点就是决定线程执行顺序。 CountDownLatch的用法 CountDownLatch，计数器初始化的数量n，当每一个线程完成自己任务后，计数器的值就会减1。 当计数器的值为0时，调用减数为n次，表示所有的线程都已经完成一些任务，，单然后在.await()上等待的线程就可以恢复执行接下来的任务。 CountDownLatch典型用法： 1、某一线程在开始运行前等待n个线程执行完毕。将
Java－理解CyclicBarrier
了解➔熟悉➔掌握➔精通
12-27 143
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 我们知道，CountDownLatch同步工具类，他是一次性的，使用完毕后，就不能再次被使用。那么有没有可以重复使用的呢？有，这次我们就了解下可以重复使用的同步工具类CyclicBarrier。 CyclicBarrier字面意思是循环栅栏，意思就是一道又一道永远走不完的栅栏。可以这么理解，就是一道道满足一定人数才能放行的栅栏。 CyclicBarrie.
Java并发编程78讲--53 第53讲：CountDownLatch 是如何安排线程执行顺序的？
g_z_q_的博客
03-05 297
下面介绍一下 CountDownLatch 的主要方法。（1）构造函数：public CountDownLatch(int count) { };它的构造函数是传入一个参数，该参数 count 是需要倒数的数值。（2）await()：调用 await() 方法的线程开始等待，直到倒数结束，也就是 count 值为 0 的时候才会继续执行。
CountDownLatch--控制三个线程执行顺序（三）
王小禾
08-28 3844
前言线程中run方法调用CountDownLatch。CountDownLatch的两个核心方法： countObj.countDown() 表示countObj计数减少。 countObj.await() 表示检查countObj若不为0则阻塞，为0，则允许执行。 比较joinjoin的工作原理是（源码），不停检查thread是否存活，如果存活则让当前线程永远wait，直到thread线程终止，线
Java 多线程技术：（四）获取线程基本信息_暂停线程_线程的优先级_多线程的安全性_线程同步
12-20
在Java编程中，多线程技术是至关重要的，特别是在处理并发任务时，它能提高程序的效率和响应性。本文将深入探讨四个关键主题：获取线程基本信息、暂停线程、线程的优先级、多线程的安全性以及线程同步。 1. 获取...
Java多线程应用练习源代码及相关说明资料
最新发布
04-26
Java多线程是Java编程中的核心概念，尤其对于后端开发人员来说，理解和掌握多线程技术至关重要。这个压缩包包含的"Java多线程应用练习源代码及相关说明资料"是一份宝贵的资源，旨在帮助学习者深入理解并实践Java的...
多线程笔记_java/多线程_
10-03
在Java编程语言中，多线程是程序设计中的一个重要概念，尤其在开发高效能和响应迅速的应用时。本文档将全面解析多线程的基础知识，从简单到复杂，帮助开发者深入理解并掌握这一核心技术。 一、多线程基础 1.1 线程...
十一. CyclicBarrier调整线程执行顺序
weixin_42480780的博客
04-29 391
CyclicBarrier调整线程执行顺序 CyclicBarrier 的字面意思是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是， 让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。线程进入屏障通过CyclicBarrier的await()方法。 public class CyclicBarrierDemo { private static final int NUMBER = 7; publ
并发工具类 CountDownLatch
小旋锋 的博客
09-01 1526
本文转载自：码农历险记 CountDownLatch CountDownLatch介绍 CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程执行完后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有框架服务之后执行。 CountDownLatch原理 CountDownLatch 是通过一个计数器来实现的，计数器的初始...
主线程与子线程的优先级问题
YuenBin128的博客
05-03 6382
在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相同。不过主线程先启动占用了cpu资源，如果存在主线程和子线程争抢cpu执行权的话，看运气，谁抢到就让谁执行。其实设置了优先级，也无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的并非没机会执行。 线程的优先级用1-10之间的整数表示，数值越大优先级越高，默认的优先级为5。...
线程3
qq_45798304的博客
11-30 109
1.线程中的常用方法： void start(): 启动线程，并执行对象的run()方法 run(): 线程在被调度时执行的操作 String getName(): 返回线程的名称 void setName(String name):设置该线程名称 static Thread currentThread(): 返回当前线程。 在Thread子类中就 是this，通常用于主线程和Runnable实现...
CountDownLatch 是如何安排线程执行顺序的？
vincent_wen0766的博客
09-16 1005
CountDownLatch，它是 JDK 提供的并发流程控制的工具类，它是在 java.util.concurrent 包下，在 JDK1.5 以后加入的 比如我们去游乐园坐激流勇进，有的时候游乐园里人不是那么多，这时，管理员会让你稍等一下，等人坐满了再开船，这样的话可以在一定程度上节约游乐园的成本。座位有多少，就需要等多少人，这就是CountDownLatch的核心思想，等到一个设定的数值达到之后，才能出发 流程图 把激流勇进的例子用流程图的方式来表示 最开始 CountDownLatc..
多线程同步器CountDownLatch、CyclicBarrier和Semaphore
l1394049664的博客
08-01 683
一、简要概述1、CountDownLatch（不可重复使用，一次性的） 当一个或多个线程需要等待指定数目的时间发生（允许线程集等待直到计数器减为0，否则会一直阻塞在调用latch.await()处） CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。 当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭...
JAVA多线程之CyclicBarrier 、CountDownLatch 、Semaphore的用法
韶shls的博客
03-31 389
1.CountDownLatch (线程计数器) 利用CountDownLatch 可以实现类似计数器的功能，比如主线程需要等待5个子线程执行完毕之后才能执行，就可以利用CountDownLatch实现，案例如下： public class TestThread { final static CountDownLatch latch = new CountDownLatch(5); ...
多线程(十一)： 计数器CountDownLatch和CyclicBarrier
人不风流枉少年
09-01 6051
public static void main(String[] args) { System.out.println(new Date() + &amp;amp;amp;quot;\t&amp;amp;amp;quot; + Thread.currentThread().getName() + &amp;amp;amp;quot;\t\trunning...&amp;amp;amp;quot;); Thread thread = new Thread(()
十. CountDownLatch调整线程顺序
weixin_42480780的博客
04-29 354
CountDownLatch可以调整线程执行顺序 CountDownLatch主要有两个方法： await()和countDown（） 当一个或多个线程调用await方法时，这些线程会阻塞。 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)， 当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。 public class Demo { public static void main(String[] args) throws In
Java多线程基础：创建与启动
Java提供了多种同步机制，如`synchronized`关键字、`Lock`接口、`Semaphore`、`CountDownLatch`和`CyclicBarrier`等，用于控制多个线程对共享资源的访问，防止数据竞争和死锁。 在Java多线程编程中，掌握这些核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值