Java 多线程的线程间的协作

已于 2024-06-20 14:51:48 修改
阅读量243 收藏
点赞数 1
分类专栏： Java并发编程 文章标签： java 开发语言
于 2023-11-05 11:33:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shangjg03/article/details/134228185
版权

1. 等待与通知

为了支持多线程之间的协作，JDK 中提供了两个非常重要的方法：wait() 和 notify() ，这两个方法定义在 Object 类中，这意味着任何 Java 对象都可以调用者两个方法。如果一个线程调用了 object.wait() 方法，那么它就会进入该对象的等待队列中，这个队列中可能包含了多个线程，此时代表多个线程都在等待同一个对象；当 object.notify() 方法被调用时，它就会从这个等待队列中随机唤醒一个线程。

需要特别注意的是在调用这两个方法时，它们都必须位于对应对象的 synchronzied 语句中，因为这两个方法在调用前都需要获得对应对象的监视器（内部锁），过程如下：

使用示例如下：

public class J3_WaitAndNotify {

    private static final Object object = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (object) {
                try {
                    System.out.println("对象object等待");
                    object.wait();
                    System.out.println("线程1后续操作");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(() -> {
            synchronized (object) {
                System.out.println("线程2开始操作");
                System.out.println("对象object唤醒");
                object.notify();
            }
        }).start();
    }
}

// 输出
对象object等待
线程2开始操作
对象object唤醒
线程1后续操作

notify() 表示随机唤醒任意一个等待线程，如果想要唤醒所有等待线程，则可以使用 notifyAll() 方法：

public class J5_NotifyAll {

    private static final Object object = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (object) {
                try {
                    System.out.println("对象object在线程1等待");
                    object.wait();
                    System.out.println("线程1后续操作");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(() -> {
            synchronized (object) {
                try {
                    System.out.println("对象object在线程2等待");
                    object.wait();
                    System.out.println("线程2后续操作");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(() -> {
            synchronized (object) {
                System.out.println("线程3开始操作");
                System.out.println("对象object唤醒");
                object.notifyAll();
            }
        }).start();
    }
}

// 输出
对象object在线程1等待
对象object在线程2等待
线程3开始操作
对象object唤醒
线程2后续操作
线程1后续操作

在上面的示例中，由于有两个线程处于等待状态，所以 notifyAll() 的效果等价于调用 notify() 两次：

object.notify();
object.notify();

2. 条件变量

综上所述可以使用 wait() 和 notify() 配合内部锁 synchronized 可以实现线程间的等待与唤醒，如果你使用的是显示锁而不是内部锁，此时可以使用 Condition 来实现同样的效果。Condition 接口中定义了如下方法：

await()：使得当前线程进入等待状态，类似于 object.wait()；
awaitUninterruptibly()：与 await() 类似，但它不会在等待过程中响应中断；
awaitNanos(long nanosTimeout) & await(long time, TimeUnit unit) & awaitUntil(Date deadline)：有时间限制的等待；
signal()：用于随机唤醒一个等待；
signalAll()：用于唤醒所有等待。

和 object 的 wait()\notify()\notifyAll() 一样，在使用 condition 的 await()\signal()\signalAll() 前，也要求线程必须持有相关的重入锁， 示例如下：

public class AwaitAndSignal {

    private static ReentrantLock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    static class IncreaseTask implements Runnable {
        @Override
        public void run() {
            try {
                lock.lock();
                String threadName = Thread.currentThread().getName();
                System.out.println(threadName + "线程等待通知...");
                condition.await();
                System.out.println(threadName + "线程后续操作");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new IncreaseTask());
        thread1.start();
        Thread.sleep(1000);
        System.out.println("主线程开始操作");
        lock.lock();
        System.out.println("主线程唤醒");
        condition.signal();
        lock.unlock();
    }
}

// 输出：
Thread-0线程等待通知...
主线程开始操作
主线程唤醒
Thread-0线程后续操作

3. Join

Thread.join() 可以让当前线程等待目标线程结束后再开始运行，示例如下：

public class J1_Normal {
    private static int j = 0;
    public static void main(String[] args)  {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                j++;
            }
        });
        thread.start();
        System.out.println(j);
    }
}
// 此时主线程不等待子线程运行完成，通常输出结果为：0

public class J2_Join {
    private static int j = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                j++;
            }
        });
        thread.start();
        thread.join();
        System.out.println(j);
    }
}
// 此时主线程需要等待子线程运行完成，输出结果为：100000

4. CountDownLatch

Thread.join() 可以让当前线程等待目标线程结束后再开始运行，但大多数时候，你只需要等待目标线程完成特定的操作，而不必等待其完全终止。此时可以使用条件变量 Condition 来实现，也可以使用更为简单的工具类 CountDownLatch 。CountDownLatch 会在内部维护一个计数器，每次完成一个任务，则计数器减 1，当计数器为 0 时，则唤醒所有的等待线程，示例如下：

public class j1_Normal {
    private static AtomicInteger integer = new AtomicInteger(0);
    static class IncreaseTask implements Runnable {
        @Override
        public void run() {
            try {
                // 假设这是一个耗时的任务
                Thread.sleep(3000);
                integer.incrementAndGet();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        IncreaseTask task = new IncreaseTask();
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 100; i++) {
            executorService.submit(task);
        }
        System.out.println("integer：" + integer);
        executorService.shutdown();
    }
}

// 不使用CountDownLatch 时，主线程不会子线程等待计算完成，此时输出通常为: 0


public class J2_CountDown {
    private static int number = 100;
    // 指定计数器的初始值
    private static CountDownLatch latch = new CountDownLatch(number);
    private static AtomicInteger integer = new AtomicInteger(0);
    static class IncreaseTask implements Runnable {
        @Override
        public void run() {
            try {
                // 假设这是一个耗时的任务
                Thread.sleep(3000);
                integer.incrementAndGet();
                // 计数器减1
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        IncreaseTask task = new IncreaseTask();
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < number; i++) {
            executorService.submit(task);
        }
        // 等待计数器为0时唤醒所有等待的线程
        latch.await();
        System.out.println("integer：" + integer);
        executorService.shutdown();
    }
}

// 使用CountDownLatch 时，主线程需要等待所有的子线程计算完成后再输出，计算结果为：100

5. CyclicBarrier

CyclicBarrier 和 CountDownLatch 类似，都是用于等待一个或者多个线程完成特定的任务后再执行某项操作，但不同的是它可以循环使用，示例如下：

/** 
 * 每五个人完成任务后,则算一个小组已完成
 */
public class J1_CyclicBarrier {

    private static CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> System.out.println("五人小组任务执行完成"));

    static class Task implements Runnable {
        @Override
        public void run() {
            try {
                long l = new Double(Math.random() * 5000).longValue();
                Thread.sleep(l);
                System.out.println("任务" + Thread.currentThread().getId() + "执行完成");
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        for (int j = 0; j < 10; j++) {
            executorService.submit(new Task());
        }
        executorService.shutdown();
    }
}

// 输出如下：
任务21执行完成
任务20执行完成
任务15执行完成
任务14执行完成
任务22执行完成
五人小组任务执行完成
任务17执行完成
任务13执行完成
任务19执行完成
任务18执行完成
任务16执行完成
五人小组任务执行完成

基于 CyclicBarrier 的特性，通常可以用于在测试环境来模仿高并发，如每次等待一万个线程启动后再让其并发执行某项压力测试。

6. Semaphore

信号量（Semaphore）可以看做是锁的扩展，由于锁的排它性，所以一次只允许一个线程来访问某个特定的资源， 而 Semaphore 则允许多个线程并发的访问某个特定的资源，并且可以通过配置许可证的数量来限制并发访问的线程数，因此其可以用于流量控制等场景中：

public class J1_Semaphore {

    // 限制并发访问的线程的数量为5
    private static Semaphore semaphore = new Semaphore(5);

    static class IncreaseTask implements Runnable {
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getId() + "获得锁!");
                Thread.sleep(5000);
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        IncreaseTask task = new IncreaseTask();
        for (int i = 0; i < 20; i++) {
            new Thread(task).start();
        }
    }
}

// 输出如下，至多只能有五个线程并发获得锁
13获得锁!
15获得锁!
16获得锁!
18获得锁!
17获得锁!
....
19获得锁!
20获得锁!
21获得锁!
22获得锁!
23获得锁!
....

7. LockSupport

LockSupport 可以在线程内的任意位置实现阻塞。它采用和 Semaphore 类似的信号量机制：它为每个线程准备一个许可，如果许可可用，则 park() 方法会立即返回，并且消费掉这个许可，让许可不可用；此时因为许可不可用，相应的线程就会被阻塞。而 unpark() 则会使得一个许可从不可用变为可用。但和 Semaphore 不同的是：它的许可不能累加，你不可能拥有超过一个许可，它永远只有一个：

public class J1_LockSupport {

    static class Task implements Runnable {
        @Override
        public void run() {
            long id = Thread.currentThread().getId();
            System.out.println("线程" + id + "开始阻塞");
            LockSupport.park();
            System.out.println("线程" + id + "解除阻塞");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread01 = new Thread(new Task());
        Thread thread02 = new Thread(new Task());
        thread01.start();
        thread02.start();
        Thread.sleep(3000);
        System.out.println("主线程干预");
        LockSupport.unpark(thread01);
        LockSupport.unpark(thread02);
    }
}

// 输出：
线程13开始阻塞
线程14开始阻塞
主线程干预
线程13解除阻塞
线程14解除阻塞
shangjg3
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 如何实现多线程之间的通讯和协作？
javamyfriend的博客
06-06 651
Java 如何实现多线程之间的通讯和协作？
线程通信：实现多线程协同
聚娃科技开发者博客
01-09 436
在多线程编程中，线程通信是指多个线程之间通过特定的机制来协同工作、共享信息的过程。线程通信是为了解决多线程环境下的数据一致性和协同处理问题而提出的。通过本文的介绍，相信你对Java中线程通信有了更深入的了解。线程通信是多线程编程中的关键话题，合理的线程通信机制能够有效提高多线程程序的性能和可靠性。
Java线程同步和协作的5种方式
qq_42747210的博客
04-29 2567
问题：有3个线程为A，B，C，同时启动，C必须等待A和B完成才能继续执行，如何实现？要求：仅使用 java 语言和它原生API使用 Java 中提供的 CountDownLatch 类实现线程之间的同步和协作使用 Java 中提供的 CyclicBarrier 类实现线程之间的同步和协作使用join()方法：Thread类提供了join()方法，可以让一个线程等待另一个线程执行完毕后再继续执行。
Java之线程协作
UohzZ的博客
02-12 169
线程通信，线程池，解决线程之间的通信问题
Java线程协作
m0_68808168的博客
07-15 98
目录线程协作生产者消费者模式线程通信-分析线程池应用场景：生产者和消费者问题假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又
Java多线程-创建线程的多种方式
RIZZ_的博客
03-21 200
Java多线程_创建线程的多种方式 一、线程与进程 ​ 几乎所有的操作系统都支持进程的概念，所有运行中的任务都对应一个进程(Process)。当一个程序进入内存运行时，即变成一个进程。进程是处于运行中的程序，并且具有一定的独立功能，进程是系统进行资源调度的一个独立单位。 ​ 一般而言，进程包含三个特征：独立性、动态性、并发性。 ​ 一个程序运行后至少会有一个进程，一个进程可以包含多个线程，但至少要有个线程。 ​ 归纳起来就是说：操作系统可以同时执行多个任务，每个任务就是进程；进程可以同时执行多个任务，
Java多线程-线程间的通信
02-02
### Java多线程—线程间的通信 #### 一、线程间的通信 ##### （1）为什么要处理线程间的通信？ 在多线程环境中，不同的线程可能需要协同工作来完成一项任务。例如，一个线程负责生产数据，另一个线程负责消费这些...
深入理解JAVA多线程之线程间的通信方式
09-02
在Java多线程编程中，线程间的通信是至关重要的，因为它确保了多个并发执行的任务能够协调工作，避免数据不一致性和死锁等问题。本文将深入探讨两种主要的线程间通信方式：同步机制和基于轮询的方式。 1. 同步机制...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
Java多线程读取大文件
12-22
总之，Java多线程读取大文件是通过文件分区、内存文件映射和NIO技术来提升效率，同时通过多线程协作和合理的资源管理确保程序的稳定性和性能。这种策略尤其适用于需要高效处理大量数据的场景，如日志分析、数据导入...
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
多线程协作机制
qq_23986927的博客
08-19 456
JAVA架构师之路 本系列文章均是博主原创，意在记录学习上的知识，同时一起分享学习心得。 第一章 第一节 Java集合总结（架构师之路 ） 第二节 Java多线程（架构师之路 ） 第三节 理解synchronized（架构师之路 ） 文章目录JAVA架构师之路前言一、协作场景二、wait/notify1.wait2.notify3、协作过程三、应用场景3.1 生产者/消费者模式3.2 同时开始3.3 等待结束3.4 异步结果3.5 集合点总结 前言 多线程之间除了竞争关系之外，还存在互相协作的情况。本
Java多线程之线程交互
carson0408的博客
03-04 8127
        线程交互是指两个线程之间通过通信联系对锁的获取与释放，从而达到较好的线程运行结果，避免引起混乱的结果。一般来说synchronized块的锁会让代码进入同步状态，即一个线程运行的同时让其它线程进行等待，那么如果需要进行实现更复杂的交互，则需要学习以下几个方法：void notify():唤醒在此对象监视器上等待的单个线程。void notifyAll():唤醒在此对象监视器上等待的...
Java多线程协作
zhangyan_1010的专栏
04-21 851
Java线程同步
java线程协作_Java多线程之线程协作
weixin_30427953的博客
02-21 148
Java多线程之线程协作一、前言上一节提到，如果有一个线程正在运行synchronized 方法，那么其他线程就无法再运行这个方法了。这就是简单的互斥处理。假如我们现在想执行更加精确的控制，而不是单纯地等待其他线程运行终止，例如下面这样的控制。● 如果空间为空则写入数据；如果非空则一直等待到变空为止● 空间已为空时，“通知”正在等待的线程此处是根据“空间是否为空”这个条件来执行线程控制的。Java...
详述Java中线程间协作
qq_46384325的博客
05-18 583
线程协作 import java.util.Date; public class Watch { private static String time; static class Display extends Thread{ @Override public void run() { System.out.println(time); } } static class Time extends Thread{ @Override public vo
Java多线程探究【四线程协作】
缘友一世的博客
11-12 445
注意：以上方法均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IegalMonitorStateException。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 452
1.导入hutool的maven依赖。2.复制一下代码执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

shangjg3

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值