脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java Condition精准唤醒线程

Java使用Condition实现精准唤醒线程详解

 更新时间：2023年02月28日 09:30:50   作者：周泽翔  
这篇文章主要为大家详细介绍了Java如何使用Condition实现精准唤醒线程效果，文中的示例代码讲解详细，感兴趣的小伙伴可以跟随小编一起了解一下

Condition简要介绍

Condition是一个接口，创建Condition的实例不能直接new，Java为我们提供一个通过Lock类实例来调用newCondition()的方法来创建。Condition因素出Object监视器方法（ wait ， notify和notifyAll ）到不同的对象，以得到具有多个等待集的每个对象，通过将它们与使用任意的组合的效果Lock个实现。 如果Lock替换了synchronized方法和语句的使用，则Condition将替换Object监视方法的使用。
条件（也称为条件队列或条件变量 ）为一个线程提供暂停执行（“等待”）的手段，直到另一个线程通知某个状态条件现在可能为真。 由于对此共享状态信息的访问发生在不同的线程中，因此必须对其进行保护，因此某种形式的锁定与该条件相关联。 等待条件提供的关键属性是它以原子方式释放关联的锁并挂起当前线程，就像Object.wait一样。

Condition里的主要方法

使用Condition的Demo

例子1

package testJUC;

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

public class TestCondition {
    public static void main(String[] args) {
        Product3 product = new Product3();
        new Thread(()->{
            for (int i = 0; i < 5; i++)
                new Producer(product).getProduct();

        },"工厂").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++)
                new Consumer(product).saleProduct();
        },"学生").start();
    }
}

class Product3 {
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private int flag = 1;//标识符

    public void getProduct() {
        //加锁
        lock.lock();
        try {
        //使用while循环，可以有效避免线程虚假唤醒
            while (flag != 1) {
                condition1.await();
            }
            flag = 2;
            //唤醒saleProduct
            condition2.signal();
            System.out.println(Thread.currentThread().getName() + "生产一个产品");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }



    public void saleProduct() {
        lock.lock();
        try {
            while (flag != 2) {
                condition2.await();
            }
            flag = 1;
            //唤醒getProduct
            condition1.signal();
            System.out.println(Thread.currentThread().getName()+"消费了一个产品");
        }catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
//实体类
class Producer{
    private Product3 product = null;
    public Producer(Product3 product) {
        this.product = product;
    }
    public void getProduct(){
        product.getProduct();
    }
}

class Consumer{
    private Product3 product = null;

    public Consumer(Product3 product) {
        this.product = product;
    }

    public void saleProduct(){
        product.saleProduct();
    }
}

结果

例子2

package testJUC;

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

public class TestCondition {
    public static void main(String[] args) {
        Print print = new Print();
        new Thread(() -> {
            for (int i = 0; i < 5; i++)
                print.printA();
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++)
                print.printB();
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++)
                print.printC();
        }).start();

    }
}


class Print {
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;

    //输出A的方法
    public void printA() {
        //加锁
        lock.lock();
        try {
            //使用while循环，可以有效避免线程虚假唤醒
            while (number != 1) {
                condition1.await();
            }
            number = 2;
            //唤醒输出B的方法
            condition2.signal();
            System.out.println("AAA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }

    }

    //输出B的方法
    public void printB() {
        //加锁
        lock.lock();
        try {
            while (number != 2) {
                condition2.await();
            }
            System.out.println("BBB");
            number = 3;
            //唤醒C
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //唤醒输出C的方法
            lock.unlock();
        }
    }

    //输出C的方法
    public void printC() {
        //加锁
        lock.lock();
        try {
            while (number != 3) {
                condition3.await();
            }
            System.out.println("CCC");
            number = 1;
            //唤醒输出A的方法
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

结果2

到此这篇关于Java使用Condition实现精准唤醒线程详解的文章就介绍到这了,更多相关Java Condition精准唤醒线程内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 谈谈java的concurrent用法

    谈谈java的concurrent用法

    这篇文章给大家介绍java的concurrent用法，感兴趣的朋友一起学习吧
    2015-10-10
  • 详解Spring Security的Web应用和指纹登录实践

    详解Spring Security的Web应用和指纹登录实践

    这篇文章主要介绍了详解Spring Security的Web应用和指纹登录实践，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2019-03-03
  • Java 十大排序算法之冒泡排序刨析

    Java 十大排序算法之冒泡排序刨析

    冒泡排序是一种简单的排序算法，它也是一种稳定排序算法。其实现原理是重复扫描待排序序列，并比较每一对相邻的元素，当该对元素顺序不正确时进行交换。一直重复这个过程，直到没有任何两个相邻元素可以交换，就表明完成了排序
    2021-11-11
  • Java中Iterator(迭代器)的用法详解

    Java中Iterator(迭代器)的用法详解

    Java迭代器（Iterator）是 Java 集合框架中的一种机制，它提供了一种在不暴露集合内部实现的情况下遍历集合元素的方法。本文主要介绍了它的使用方法，希望对大家有所帮助
    2023-05-05
  • IDEA类存在但找不到的解决办法

    IDEA类存在但找不到的解决办法

    本文主要介绍了IDEA类存在但找不到的解决办法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-07-07
  • Java递归寻路实现,你真的理解了吗

    Java递归寻路实现,你真的理解了吗

    递归就是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,需要的朋友可以参考下
    2021-08-08
  • Spring Boot中使用Spring Retry重试框架的操作方法

    Spring Boot中使用Spring Retry重试框架的操作方法

    这篇文章主要介绍了Spring Retry 在SpringBoot 中的应用,介绍了RetryTemplate配置的时候，需要设置的重试策略和退避策略，需要的朋友可以参考下
    2022-04-04
  • SpringMVC获取请求参数的方法详解

    SpringMVC获取请求参数的方法详解

    这篇文章主要为大家详细介绍了SpringMVC中获取请求参数的方法，例如通过ServletAPI获取和通过控制器方法的形参获取请求参数等，需要的可以参考下
    2023-07-07
  • SpringBoot 使用 @Value 注解读取配置文件给静态变量赋值

    SpringBoot 使用 @Value 注解读取配置文件给静态变量赋值

    这篇文章主要介绍了SpringBoot 使用 @Value 注解读取配置文件给静态变量赋值，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-11-11
  • MyBatis如何进行双重foreach循环

    MyBatis如何进行双重foreach循环

    这篇文章主要介绍了MyBatis如何进行双重foreach循环，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-02-02

最新评论