Java Object对象中的wait,notify,notifyAll的理解

wait,notify,notifyAll 是定义在Object类的实例方法,用于控制线程状态,在线程协作时,大家都会用到notify()或者notifyAll()方法,其中wait与notify是java同步机制中重要的组成部分,需要结合与synchronized关键字才能使用,在调用一个Object的wait与notify/notifyAll的时候,必须保证调用代码对该Object是同步的,也就是说必须在作用等同于synchronized(object){......}的内部才能够去调用obj的wait与notify/notifyAll三个方法,否则就会报错:java.lang.IllegalMonitorStateException:current thread not owner(意思是因为没有同步,所以线程对对象锁的状态是不确定的,不能调用这些方法)。

wait的目的就在于暴露出对象锁,所以需要保证在lock的同步代码中调用lock.wait()方法,让其他线程可以通过对象的notify叫醒等待在该对象的等该池里的线程。同样notify也会释放对象锁,在调用之前必须获得对象的锁,不然也会报异常。所以,在线程自动释放其占有的对象锁后,不会去申请对象锁,只有当线程被唤醒的时候或者达到最大的睡眠时间,它才再次争取对象锁的权利

主要方法:

(1).wait()
等待对象的同步锁,需要获得该对象的同步锁才可以调用这个方法,否则编译可以通过,但运行时会收到一个异常:IllegalMonitorStateException。调用任意对象的 wait() 方法导致该线程阻塞,该线程不可继续执行,并且该对象上的锁被释放。

(2).notify()
唤醒在等待该对象同步锁的线程(只唤醒一个,如果有多个在等待),注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。调用任意对象的notify()方法则导致因调用该对象的 wait()方法而阻塞的线程中随机选择的一个解除阻塞(但要等到获得锁后才真正可执行)。

(3).notifyAll()
唤醒所有等待的线程,注意唤醒的是notify之前wait的线程,对于notify之后的wait线程是没有效果的。

通过一个实例来看一下实际的效果,开启两个线和,一个线程 打印1到52的数字,一个打印A到Z的字母,要求,打印两个数,打印一个字母,这样交替顺序打印,代码如下:

/**
 * create by spy on 2018/6/4
 */
public class ShuZiZiMuThread {

    public static void main(String[] args) {
        Object object = new Object();
        shuzi shuzi = new shuzi(object);
        zimu zimu = new zimu(object);
        Thread t = new Thread(shuzi);
        t.setName("shuzi");
        Thread t1 = new Thread(zimu);
        t1.setName("zimu");
        t.start();//数字线程先运行
        t1.start();
    }
}

class shuzi implements Runnable{
    private Object object;
    //声明类的引用
    public shuzi(Object object) {
        this.object = object;
    }

    public void run() {
        synchronized (object) {//上锁

            for(int i=1;i<53;i++){
                System.out.print(i+",");
                if(i%2==0){
                    object.notifyAll();//唤醒其它争夺权限的线程
                    try {
                        object.wait();//释放锁,进入等待
                        System.out.println("数字打印类打全打印当前对象拥有对象锁的线程"+Thread.currentThread().getName());//输出当前拥有锁的线程名称
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

class zimu implements Runnable{
    private Object object;
    public zimu(Object object) {

        this.object = object;
    }
    public void run() {
        synchronized (object) {
            for(int j=65;j<91;j++){
                char c = (char)j;
                System.out.print(c);
                object.notifyAll();//唤醒其它争夺权限的线程
                try {
                    object.wait();//释放锁,进入等待
                    System.out.println("字母打印类打全打印当前对象拥有对象锁的线程"+Thread.currentThread().getName());//输出当前拥有锁的线程名称
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

实际运行的结果 :

1,2,A数字打印类打印当前对象拥有对象锁的线程shuzi
3,4,字母打印类打印当前对象拥有对象锁的线程zimu
B数字打印类打印当前对象拥有对象锁的线程shuzi
5,6,字母打印类打印当前对象拥有对象锁的线程zimu
C数字打印类打印当前对象拥有对象锁的线程shuzi
7,8,字母打印类打印当前对象拥有对象锁的线程zimu
D数字打印类打印当前对象拥有对象锁的线程shuzi
9,10,字母打印类打印当前对象拥有对象锁的线程zimu
E数字打印类打印当前对象拥有对象锁的线程shuzi
11,12,字母打印类打印当前对象拥有对象锁的线程zimu
F数字打印类打印当前对象拥有对象锁的线程shuzi
13,14,字母打印类打印当前对象拥有对象锁的线程zimu
G数字打印类打印当前对象拥有对象锁的线程shuzi
15,16,字母打印类打印当前对象拥有对象锁的线程zimu
H数字打印类打印当前对象拥有对象锁的线程shuzi
17,18,字母打印类打印当前对象拥有对象锁的线程zimu
I数字打印类打印当前对象拥有对象锁的线程shuzi
19,20,字母打印类打印当前对象拥有对象锁的线程zimu
J数字打印类打印当前对象拥有对象锁的线程shuzi
21,22,字母打印类打印当前对象拥有对象锁的线程zimu
K数字打印类打印当前对象拥有对象锁的线程shuzi
23,24,字母打印类打印当前对象拥有对象锁的线程zimu
L数字打印类打印当前对象拥有对象锁的线程shuzi
25,26,字母打印类打印当前对象拥有对象锁的线程zimu
M数字打印类打印当前对象拥有对象锁的线程shuzi
27,28,字母打印类打印当前对象拥有对象锁的线程zimu
N数字打印类打印当前对象拥有对象锁的线程shuzi
29,30,字母打印类打印当前对象拥有对象锁的线程zimu
O数字打印类打印当前对象拥有对象锁的线程shuzi
31,32,字母打印类打印当前对象拥有对象锁的线程zimu
P数字打印类打印当前对象拥有对象锁的线程shuzi
33,34,字母打印类打印当前对象拥有对象锁的线程zimu
Q数字打印类打印当前对象拥有对象锁的线程shuzi
35,36,字母打印类打印当前对象拥有对象锁的线程zimu
R数字打印类打印当前对象拥有对象锁的线程shuzi
37,38,字母打印类打印当前对象拥有对象锁的线程zimu
S数字打印类打印当前对象拥有对象锁的线程shuzi
39,40,字母打印类打印当前对象拥有对象锁的线程zimu
T数字打印类打印当前对象拥有对象锁的线程shuzi
41,42,字母打印类打印当前对象拥有对象锁的线程zimu
U数字打印类打印当前对象拥有对象锁的线程shuzi
43,44,字母打印类打印当前对象拥有对象锁的线程zimu
V数字打印类打印当前对象拥有对象锁的线程shuzi
45,46,字母打印类打印当前对象拥有对象锁的线程zimu
W数字打印类打印当前对象拥有对象锁的线程shuzi
47,48,字母打印类打印当前对象拥有对象锁的线程zimu
X数字打印类打印当前对象拥有对象锁的线程shuzi
49,50,字母打印类打印当前对象拥有对象锁的线程zimu
Y数字打印类打印当前对象拥有对象锁的线程shuzi
51,52,字母打印类打印当前对象拥有对象锁的线程zimu
Z数字打印类打印当前对象拥有对象锁的线程shuzi

结果分析:

通过结果可以看出:

在字母打一打印类里 调用完

object.notifyAll();//唤醒其它争夺权限的线程
object.wait();//释放锁,进入等待后,拥有对象锁的线程是shuzi

在数字打印类里 调用完

object.notifyAll();//唤醒其它争夺权限的线程
object.wait();//释放锁,进入等待后,拥有对象锁的线程是zimu

原文地址:https://www.cnblogs.com/songpingyi/p/9134805.html

时间: 2024-08-29 11:12:37

Java Object对象中的wait,notify,notifyAll的理解的相关文章

Java Object 对象上的wait(),notify(),notifyAll()方法理解

第一阶段理解(2017-7-27): Java 将wait(),notify(),notifyAll()方法放在Object对象上,也就是说任何一个对象都可以调用这个方法,这与”任何一个对象都有一个内置锁,可以用于线程同步“是照应的.因此,当某个线程要释放cpu争夺权,让自己进入等待状态时,调用 某个锁(对象)上的wait()方法,也就是让当前线程等待其它线程调用该锁上的notify()或notify()方法.线程间通过同步锁来实现等待与唤醒协作.简单例子: 1 package com.lyyc

Java之Object对象中的wait()和notifyAll()用法

用一个例子来说明Object对象中的wait方法和notifyAll方法的使用. 首先定义一个消息类,用于封装数据,以供读写线程进行操作: 1 /** 2 * 消息 3 * 4 * @author syj 5 */ 6 public class Message { 7 8 private String msg; 9 10 public String getMsg() { 11 return msg; 12 } 13 14 public void setMsg(String msg) { 15 t

Object中的wait,notify,notifyAll基本使用(转)

Object中的wait,notify,notifyAll基本使用 Obj.wait(),与Obj.notify()必须要与synchronized(Obj)一起使用,也就是wait,与notify是针对已经获取了Obj锁进行操作,从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){…}语句块内.从功能上来说wait就是说线程在获取对象锁后,主动释放对象锁,同时本线程休眠.直到有其它线程调用对象的notify()唤醒该线程,才能继续获取对象锁,并

JAVA线程间协作:wait.notify.notifyAll

JAVA的进程同步是通过synchronized()来实现的,须要说明的是,JAVA的synchronized()方法相似于操作系统概念中的相互排斥内存块.在JAVA中的Object类型中.都是带有一个内存锁的,在有线程获取该内存锁后.其它线程无法訪问该内存.从而实现JAVA中简单的同步.相互排斥操作. 明确这个原理.就能理解为什么synchronized(this)与synchronized(static XXX)的差别了.synchronized就是针对内存区块申请内存锁,thiskeywo

Java Object 对象创建的方式 [ 转载 ]

Java Object 对象创建的方式 [ 转载 ] @author http://blog.csdn.net/mhmyqn/article/details/7943411 显式创建 有4种显式地创建对象的方式: 1.构造器:用new语句创建对象,这是最常用的创建对象的方式. 2.反射:运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法. 3.克隆:调用对象的clone()方法. 4.序列化:运用反

Java Object 对象序列化和反序列化

Java Object 对象序列化和反序列化 @author ixenos 对象序列化是什么 1.对象序列化就是把一个对象的状态转化成一个字节流. 我们可以把这样的字节流存储为一个文件,作为对这个对象的复制(深拷贝):在一些分布式应用中,我们还可以把对象的字节流发送到网络上的其他计算机. 反序列化是把流结构的对象恢复为其原有形式 2.Java平台允许我们在内存中创建可复用的Java对象,但一般情况下,只有当JVM处于运行时,这些对象才可能存在,即,这些对象的生命周期不会比JVM的生命周期更长.但

Java Object 对象序列化后的文件格式

Java Object 对象序列化后的文件格式 @author ixenos 1.文件开头: AC ED 2.序列化格式版本示例: 00 05 3.字符串对象示例: 74 2字节表示的字符串长度 字符串: 74 00 05 ixenos 4.类序列化示例:当存储一个对象时,其类也被存储: 类名 序列化版本号ID指纹 序列化方法 数据域 72 2字节的类名长度 类名 8字节的指纹 1字节的标志 //由在java.io.ObjectStream.Constant中定义的三位掩码(三个字节常量)构成

关于java同步包中ConcurrentLinkedQueue类的深入分析与理解

一,官方描述 一个基于连接节点的无界线程安全队列.这个队列的顺序是先进先出.队列头部的元素是留在队列中时间最长的,队列尾部的元素是留在队列中时间最短的.新元素被插入到元素的尾部,队列从队列的头部检索元素.当许多线程共享访问同一个集合时,这个类是不二选择.这个队列不允许有null元素. 这个实现基于一种被描述为简单,快速,实用的非阻塞和阻塞公布队列算法而提供的一种有效的空闲等待算法. 注意,不像大多数集合,size方法的操作不是常量时间的,由于是异步队列,决定了元素的数量需要遍历真个元素集. 这个

Java多线程8:wait()和notify()/notifyAll()

轮询 线程本身是操作系统中独立的个体,但是线程与线程之间不是独立的个体,因为它们彼此之间要相互通信和协作. 想像一个场景,A线程做int型变量i的累加操作,B线程等待i到了10000就打印出i,怎么处理?一个办法就是,B线程while(i == 10000),这样两个线程之间就有了通信,B线程不断通过轮训来检测i == 10000这个条件. 这样可以实现我们的需求,但是也带来了问题:CPU把资源浪费了B线程的轮询操作上,因为while操作并不释放CPU资源,导致了CPU会一直在这个线程中做判断操