Java并发之等待/通知机制

编程之家收集整理的这篇文章主要介绍了Java并发之等待/通知机制编程之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

搜索热词


1 前言

本篇文章默认大家对synchronizedReentrantLock有一定了解。

1.1 先来段代码放松一下

下面一段简单的代码,主要是通过3个线程对count进行累计来进行模拟多线程的场景。

/**
 * zhongxianyao
 */
public class Test {
    private static final int N = 3;
    private int count = 0;

    public void doSomething() {
        // 实际业务中,这里可能是远程获取数据之类的耗时操作
        for (int i=0; i<1000_000; i++) {
            synchronized (this) {
                count ++;
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Test test = new Test();
        for (int i=0; i<N; i++) {
            Runnable runnable = () -> test.doSomething();
            new Thread(runnable).start();
        }

        Thread.sleep(1000);
        System.out.println(test.count);
    }

}

在多线程编程中,一旦调用start()后,什么时候真正分配cpu时间片运行是不确定的,运行多久也是不确定的,所以有时候可能根据经验,预估一下程序的运行时间,然后进行sleep,最后获取结果。但这种方式太low了,有没有那么一种方式,当程序获取到结果后进行通知呢?下面将引出今天要讲的等待/通知机制。


2 Object wait()/notify()

2.1 一段入门代码

先来一段代码看一下wait()/notify()的基本用法

/**
 * zhongxianyao
 */
public class Test {

    private static final int N = 3;
    private int count = 0;
    private int finishCount = 0;

    public void doSomething() {
        for (int i=0; i<1000_000; i++) {
            synchronized (this) {
                count ++;
            }
        }
        synchronized (this) {
            finishCount ++;
            notify();
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        for (int i=0; i<N; i++) {
            Runnable runnable = () -> test.doSomething();
            new Thread(runnable).start();
        }

        synchronized (test) {
            try {
                while (test.finishCount != N) {
                    test.wait();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        System.out.println(test.count);
    }

}

结果输出3000000,结果是正确,是自己想要的。

2.2 问题三连击

a.为什么官方说wait() 要放在while里面?

接口描述如下

As in the one argument version,interrupts and spurIoUs wakeups are possible,and this method should always be used in a loop:
     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait();
         ... // Perform action appropriate to condition
     }

翻译一下:在一个论点版本中,中断跟虚假唤醒是可能,所以这个方法应始终放在一个循环中。

加上一句自己的解释:一般在项目中,一个线程不可能无缘无故等待,总是需要在某种条件下进行等待,而且其他线程唤醒这个线程的时候,可能用的是notifyAll(),数据被其他线程消费了,这里需要在判断一下是否满足特定的条件再继续运行。

b.为什么wait()必须在同步方法/代码块中调用

解释1:wait()本身设计的逻辑就是在释放锁进行等待,如果没有获取锁,谈何释放。

解释2:通常在wait()的方法前面都会有while语句的判断,在这两条语句中会有时间间隔,可能会破坏程序,需要加上synchronized同步代码块来保证原子操作。

c.为什么wait(),notify() 和 notifyAll()是定义在Object里面而不是在Thread里面?

因为wait()等方法都是锁级别操作,再者Java提供的锁都是对象级别的而不是线程级别的,每个对象都有锁。如果wait()方法定义在Thread类中,线程正在等待的是哪个锁就不明显了。

2.3 wait(long timeout)

在上面的例子中,如果notify();那行代码删除wait()改为wait(100),如下,那么程序是否可以获取到正确的结果呢?

/**
 * zhongxianyao
 */
public class Test {

    private static final int N = 3;
    private int count = 0;
    private int finishCount = 0;

    public void doSomething() {
        for (int i=0; i<1000_000; i++) {
            synchronized (this) {
                count ++;
            }
        }
        synchronized (this) {
            finishCount ++;
            //notify();
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        for (int i=0; i<N; i++) {
            Runnable runnable = () -> test.doSomething();
            new Thread(runnable).start();
        }

        synchronized (test) {
            try {
                while (test.finishCount != N) {
                    test.wait(100);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        System.out.println(test.count);
    }

}

运行结果是3000000,是正确的结果,看了一下文档,发现这个字段跟直觉理解的不一样,直觉告诉我,这个是最长等多久,等太久了就InterruptedException,结果不是。这个方法设置的时间,是说等待多久就唤醒自己。


3 Condition await()/signal()

3.1 用Condition进行替换

下面的代码,把前一个例子中的synchronized代码块,换成了lock()/unlock,notify()换成了condition.signal(),wait()换成了condition.await()。运行结果也是正确的。

/**
 * zhongxianyao
 */
public class Test {

    private static final int N = 3;
    private int count = 0;
    private int finishCount = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void doSomething() {
        for (int i=0; i<1000_000; i++) {
            synchronized (this) {
                count ++;
            }
        }
        lock.lock();
        finishCount ++;
        if (finishCount == N) {
            condition.signal();
        }
        lock.unlock();
    }

    public static void main(String[] args) {
        Test test = new Test();
        for (int i=0; i<N; i++) {
            Runnable runnable = () -> test.doSomething();
            new Thread(runnable).start();
        }

        test.lock.lock();
        try {
            test.condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            test.lock.unlock();
        }

        System.out.println(test.count);
    }

}

3.2 signal()方法后不建议添加逻辑

public class ConditionTest {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            try {
                long time = System.currentTimeMillis();
                lock.lock();
                System.out.println("await start");
                condition.await();
                System.out.println("await end " + (System.currentTimeMillis() - time) + "ms");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        },"Thread-await").start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        new Thread(() -> {
            try {
                lock.lock();
                System.out.println("signal start");
                TimeUnit.SECONDS.sleep(5);
                condition.signal();
                System.out.println("signal end");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
                System.out.println("signal unlock");
            }
        },"Thread-signal").start();

    }
}

多次运行,结果都是一样的,如下:

await start
signal start
signal end
signal unlock
await end 5005ms

从运行结果可以看出,await()后,锁就释放了,但signal()后,锁不释放,一定要在unlock()之后,锁才释放,await()才会往下执行。

既然唤醒了其他线程,又不释放锁,可以调整唤醒的时机。一般在实际代码中,也是不建议signal()方法添加逻辑,应该直接释放锁。

同理,上面的notify()也是在synchronized代码块结束后,wait()后面的语句才能真正执行。

3.3 boolean await(long time,TimeUnit unit)

把上面的condition.await()改为condition.await(1,TimeUnit.SECONDS),然后获取返回值,运行结果返回的是false

这个时候,如果把TimeUnit.SECONDS.sleep(5)condition.signal()这两行代码顺序调换一下,那么await的返回值就是true

再看到官方文档对这个返回值的描述,如下

{@code false} if the waiting time detectably elapsed
before return from the method,else {@code true}

翻译过来,大致意思就是“如果等待时间可以在方法返回之前检测到返回false,否则返回true”。但实际测试结果却是await()被唤醒的时候,而不是方法返回的时候。


4 区别

  • Object wait() notify() 搭配synchronized使用
  • Condition await() signal() 搭配Lock使用
  • Object notify() 是随机唤醒一个
  • Condition signal() 是唤醒第一个await()的线程
  • Object wait()有虚假唤醒,而Condition await() 没有

5 参考文档

总结

以上是编程之家为你收集整理的Java并发之等待/通知机制全部内容,希望文章能够帮你解决Java并发之等待/通知机制所遇到的程序开发问题。

如果觉得编程之家网站内容还不错,欢迎将编程之家网站推荐给程序员好友。

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您喜欢寻找一群志同道合、互帮互助的学习伙伴,可以点击下方链接加入:
编程之家官方1群:1065694478(已满)
编程之家官方2群:163560250(已满)
编程之家官方3群:312128206

相关文章

猜你在找的Java相关文章

ArrayList简介:ArrayList 的底层是数组队列,相当于动态数组。与 Java 中的数组相比,它的容量能动态增长。在添加大量元素前,应用程序可以使用ensureCapacity操作来增加
一、进程与线程 进程:是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位。 线程:是进程的一个执行路径,一个进程中至少有一个线程,进程中的多个线程共享进程的 资源。 虽然系统是把资源
#############java面向对象详解#############1、面向对象基本概念2、类与对象3、类和对象的定义格式4、对象与内存分析5、封装性6、构造方法7、this关键字8、值传递与引用
一、什么是异常? 异常就是有异于常态,和正常情况不一样,有错误出错。在java中,阻止当前方法或作用域正常运行的情况,称之为异常。 二、异常体系 Java把异常当作对象来处理,并定义一个基类java.
//Map的四种遍历方法 //Map不能直接遍历 ,只能通过遍历Key与Value间接遍历 public static void main(String[] args) { Map&lt;String
一,抛出异常有三种形式,一是throw,一个throws,还有一种系统自动抛异常。下面它们之间的异同。 (1)、系统自动抛异常 1.当程序语句出现一些逻辑错误、主义错误或类型转换错误时,系统会自动抛出
Jdk 频繁更新,新特性了解吗?每次更新都注重提高生产效率,提高 JVM 性能,推行模块化等,让开发者可以更多的专注于业务本身,而不是浪费过多的时间在语言特性上。Java 语言的更新要在语言的严谨性和
Java 12 早在 2019 年 3 月 19 日发布,这些新特性你知道吗