JAVA线程间协作：Condition

最新推荐文章于 2023-11-05 11:33:14 发布
最新推荐文章于 2023-11-05 11:33:14 发布
阅读量6k 收藏 3
点赞数 1
分类专栏： java JAVA相关技术 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013256816/article/details/50445241
版权 
欢迎支持笔者新作：《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客。

欢迎跳转到本文的原文链接：https://honeypps.com/java/java-multi-thread-of-condition/

    内置条件队列存在一些缺陷。每个内置锁都只能有一个相关联的条件队列，因而在像BounderBuffer这种类中，多个线程可能在同一个条件队列上等待不同的条件谓词，并且在最常见的加锁模式下公开条件队列对象。这些因素都使得无法满足在使用notifyAll时所有等待线程为统一类型的需求。如果想编写一个带有多个条件谓词的并发对象，或者想获得除了条件队列可见性之外的更多控制权，就可以使用显示的Lock和Condition而不是内置锁和条件队列，这是一种更灵活的选择。

    一个Condition和一个Lock关联在一起，就想一个条件队列和一个内置锁相关联一样。要创建一个Condition，可以在相关联的Lock上调用Lock.newCondition方法。正如Lock比内置加锁提供了更为丰富的功能，Condition同样比内置条件队列提供了更丰富的功能：在每个锁上可存在多个等待、条件等待可以是可中断的或者不可中断的、基于时限的等待，以及公平的或非公平的队列操作。

    与内置条件队列不同的是，对于每个Lock，可以有任意数量的Condition对象。Condition对象继承了相关的Lock对象的公平性，对于公平的锁，线程会依照FIFO顺序从Condition.await中释放。

Condition接口：

 

public interface Condition{
    void await() throws InterruptedException;
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    void awaitUniterruptibly();
    boolean awaitUntil(Date deadline) throws InterruptedException;
    void signal();
    void signalAll();
}

    注意：在Condition对象中，与wait,notify和notifyAll方法对于的分别是await,signal,signalAll。但是，Condition对Object进行了扩展，因而它也包含wait和notify方法。一定要确保使用的版本——await和signal.
官方使用方法如下：

class BoundedBuffer
{
    final Lock lock = new ReentrantLock();
    final Condition notFull = lock.newCondition();
    final Condition notEmpty = lock.newCondition();

    final Object[] items = new Object[100];
    int putptr, takeptr, count;

    public void put(Object x) throws InterruptedException
    {
        lock.lock();
        try
        {
            while (count == items.length)
                notFull.await();
            items[putptr] = x;
            if (++putptr == items.length)
                putptr = 0;
            ++count;
            notEmpty.signal();
        }
        finally
        {
            lock.unlock();
        }
    }

    public Object take() throws InterruptedException
    {
        lock.lock();
        try
        {
            while (count == 0)
                notEmpty.await();
            Object x = items[takeptr];
            if (++takeptr == items.length)
                takeptr = 0;
            --count;
            notFull.signal();
            return x;
        }
        finally
        {
            lock.unlock();
        }
    }
}

    或者通过一个实际的例子来解释Condition的用法：
    我们要打印1-9这0个数字，由A线程先打印1-3，然后由B线程打印4-6，然后再由A线程打印7-9.我们采用Condition来演示解决方法：

package com.cooperation;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestCondition
{
    private static int value = 1;
    private Lock lock = new ReentrantLock();
    private Condition Condition456 = lock.newCondition();
    private Condition Condition789 = lock.newCondition();

    class ThreadA implements Runnable{
        @Override
        public void run()
        {
            try
            {
                lock.lock();
                System.out.println("首先输出1-3");
                while(value<=3)
                {
                    System.out.println(value++);
                }
                Condition456.signal();
            }
            finally
            {
                lock.unlock();
            }

            try
            {
                lock.lock();
                while(value<=6)
                {
                    Condition789.await();
                }
                System.out.println("输出7-9");
                while(value<=9)
                {
                    System.out.println(value++);
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            finally
            {
                lock.unlock();
            }

        }
    }

    class ThreadB implements Runnable{
        @Override
        public void run()
        {
            try
            {
                lock.lock();
                while(value<=3)
                {
                    Condition456.await();
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            finally{
                lock.unlock();
            }

            try{
                lock.lock();
                System.out.println("输出4-6");
                while(value<=6)
                {
                    System.out.println(value++);
                }
                Condition789.signal();
            }
            finally
            {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args)
    {
        TestCondition test = new TestCondition();
        Thread threadA = new Thread(test.new ThreadA());
        Thread threadB = new Thread(test.new ThreadB());
        threadA.start();
        threadB.start();
    }

}

输出结果：

 

 

首先输出1-3
1
2
3
输出4-6
4
5
6
输出7-9
7
8
9

    如果需要采用Object方法的wait,notify,notifyAll方法实现这个实例可以参考：http://outofmemory.cn/java/java.util.concurrent/thread-sync-with-object-wait-notify-notifyAll
    同样可以扩张，ThreadA打印123，ThreadB打印456，再让ThreadA打印789，最后然ThreadB打印10 11 12.如下：

package com.cooperation;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestCondition
{
    private static int value = 1;
    private Lock lock = new ReentrantLock();
    private Condition Condition456 = lock.newCondition();
    private Condition Condition789 = lock.newCondition();
    private Condition Condition101112 = lock.newCondition();

    class ThreadA implements Runnable{
        @Override
        public void run()
        {
            try
            {
                lock.lock();
                System.out.println("首先输出1-3");
                while(value<=3)
                {
                    System.out.println(value++);
                }
                Condition456.signal();
            }
            finally
            {
                lock.unlock();
            }

            try
            {
                lock.lock();
                while(value<=6)
                {
                    Condition789.await();
                }
                System.out.println("输出7-9");
                while(value<=9)
                {
                    System.out.println(value++);
                }
                Condition101112.signal();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            finally
            {
                lock.unlock();
            }

        }
    }

    class ThreadB implements Runnable{
        @Override
        public void run()
        {
            try
            {
                lock.lock();
                while(value<=3)
                {
                    Condition456.await();
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            finally{
                lock.unlock();
            }

            try{
                lock.lock();
                System.out.println("输出4-6");
                while(value<=6)
                {
                    System.out.println(value++);
                }
                Condition789.signal();
            }
            finally
            {
                lock.unlock();
            }

            try
            {
                lock.lock();
                while(value<=9)
                {
                    Condition101112.await();
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            finally{
                lock.unlock();
            }

            try{
                lock.lock();
                System.out.println("输出10-12");
                while(value<=12)
                {
                    System.out.println(value++);
                }
            }
            finally
            {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args)
    {
        TestCondition test = new TestCondition();
        Thread threadA = new Thread(test.new ThreadA());
        Thread threadB = new Thread(test.new ThreadB());
        threadA.start();
        threadB.start();
    }
}

输出结果：

 

 

首先输出1-3
1
2
3
输出4-6
4
5
6
输出7-9
7
8
9
输出10-12
10
11
12

欢迎跳转到本文的原文链接：https://honeypps.com/java/java-multi-thread-of-condition/

 

欢迎支持笔者新作：《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客。

朱小厮
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程间的通信方式详解
09-02
主要为大家详细介绍了Java线程间的通信方式，以代码结合文字的方式来讨论线程间的通信，感兴趣的朋友可以参考一下
线程协作的三种方式
狐言
03-27 1312
线程之间需要进行通信，通信有数据共享和线程协作两种方式，这篇主要说线程协作的内容。 一：数据共享 1：文件共享；2：网络共享；3：变量共享。 二：线程协作 先来个场景：落魄程序员摆摊卖起了炒粉，起先有人去买炒粉，发现炒粉卖完了，只能失落的回家了；后来为了不让客户白来一趟，落魄程序员想到了一个办法，线上预定。要是没有炒粉了，客户就不要白跑了，要是炒粉做好了，就通知客户。 2...
Java线程同步和协作的5种方式
qq_42747210的博客
04-29 2447
问题：有3个线程为A，B，C，同时启动，C必须等待A和B完成才能继续执行，如何实现？要求：仅使用 java 语言和它原生API使用 Java 中提供的 CountDownLatch 类实现线程之间的同步和协作使用 Java 中提供的 CyclicBarrier 类实现线程之间的同步和协作使用join()方法：Thread类提供了join()方法，可以让一个线程等待另一个线程执行完毕后再继续执行。
线程间协作
weixin_42867975的博客
08-24 325
线程间协作 一、线程间协作：线程间的协作是为了解决线程执行时谁先谁后的为题，可以合理的确定多线程中线程的先后执行顺序 二、线程协作使用的方法：谁调用了wait方法，谁就必须调用notify或notifyAll方法，并且“谁”是对象锁 wait():对象锁调用了wait()方法，会使持有该对象锁的对象处于阻塞状态并释放对象锁的控制权，直到其他线程中的对象锁调用notify()方法或notif...
Java 多线程的线程间的协作
shangjg3的博客
11-05 136
为了支持多线程之间的协作，JDK 中提供了两个非常重要的方法：wait() 和 notify() ，这两个方法定义在 Object 类中，这意味着任何 Java 对象都可以调用者两个方法。当 object.notify() 方法被调用时，它就会从这个等待队列中随机唤醒一个线程。综上所述可以使用 wait() 和 notify() 配合内部锁 synchronized 可以实现线程间的等待与唤醒，如果你使用的是显示锁而不是内部锁，此时可以使用 Condition 来实现同样的效果。
Java 如何实现多线程之间的通讯和协作？
javamyfriend的博客
06-06 615
Java 如何实现多线程之间的通讯和协作？
java并发编程：线程基础
08-09
本资源致力于向您介绍 Java 并发编程中的线程基础，涵盖了多线程编程的核心概念、线程的创建和管理，以及线程间通信的基本方法。通过深入学习，您将建立扎实的多线程编程基础，能够更好地理解和应用多线程编程。 多...
Python线程协作threading.Condition实现过程解析
09-17
主要介绍了Python线程协作threading.Condition实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程-线程间的通信
最新发布
02-02
Java多线程--线程间的通信
深入理解JAVA多线程之线程间的通信方式
09-02
下面小编就为大家带来一篇深入理解JAVA多线程之线程间的通信方式。小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java之线程协作
UohzZ的博客
02-12 159
线程通信，线程池，解决线程之间的通信问题
Java线程协作
m0_68808168的博客
07-15 90
目录线程协作生产者消费者模式线程通信-分析线程池应用场景：生产者和消费者问题假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又
java线程协作_Java多线程之线程协作
weixin_30427953的博客
02-21 124
Java多线程之线程协作一、前言上一节提到，如果有一个线程正在运行synchronized 方法，那么其他线程就无法再运行这个方法了。这就是简单的互斥处理。假如我们现在想执行更加精确的控制，而不是单纯地等待其他线程运行终止，例如下面这样的控制。● 如果空间为空则写入数据；如果非空则一直等待到变空为止● 空间已为空时，“通知”正在等待的线程此处是根据“空间是否为空”这个条件来执行线程控制的。Java...
详述Java中线程间协作
qq_46384325的博客
05-18 572
线程协作 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
[多线程]线程协作
qq_17850439的博客
05-03 153
什么是线程协作？ 线程协作指不同线程驱动的任务相互依赖，依赖一般就是对共享资源的依赖； 有线程协作一定会有资源共享，有共享就有竞争，有竞争就会有线程安全问题；但是synchronized与lock只能实现线程同步，并不能实现线程的协作。而实现线程协作，则需要wait（）与notify（）方法。 wait与notify wait():表示线程一直等待，直到其他线程通知，与sleep不同，它会释放锁。 wait(long timeout):指定等待的毫秒数。 notify():唤醒一个处于等待状态的线程。 n
多线程详解第5讲：线程协作
林深不见鹿 的博客
04-23 5743
线程协作 这里写目录标题线程协作1、线程通信2、线程通信分析3、解决方式14、解决方式25、使用线程池 1、线程通信 应用场景 : 生产者和消费者问题 假设仓库中只能存放一件产品 , 生产者将生产出来的产品放入仓库 , 消费者将仓库中产品取走消费 如果仓库中没有产品 , 则生产者将产品放入仓库 , 否则停止生产并等待 , 直到仓库中的产品被消费者取走为止 如果仓库中放有产品 , 则消费者可以将产品取走消费 , 否则停止消费并等待 , 直到仓库中再次放入产品为止 2、线程通信分析 这是一个线程同步问题
Java并发编程学习十：线程协作
weixin_41402069的博客
08-02 414
Java并发编程学习系列
Java基础-线程的协作机制
m0_72882572的博客
10-24 480
线程的协作机制 多线程之间的核心问题，除了竞争，就是协作。我们在15.3节介绍了多种协作场景，比如生产者/消费者协作模式、主从协作模式、同时开始、集合点等。之前章节探讨了协作的多种机制： ·wait/notify； ·显式条件； ·线程的中断；
java多线程八股面试
10-07
3. 线程通信与协作：包括wait()、notify()、notifyAll()方法、Condition接口、线程间的通信与协作方式等。 4. 线程池与线程调度：包括线程池的概念、线程池的实现原理、线程池的工作队列、线程池参数的配置等。 5. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值