`

java的wait与notify

阅读更多

      wait与notify是java同步机制中重要的组成部分。结合与synchronized关键字使用,可以建立很多优秀的同步模型。

      synchronized(this){}等价与public synchronized void method(){.....}

      同步分为类级别和对象级别,分别对应着类锁和对象锁。类锁是每个类只有一个,如果static的方法被synchronized关键字修饰,则在这个方法被执行前必须获得类锁;对象锁与类锁类似。

      首先,调用一个Object的wait与notify/notifyAll的时候,必须保证调用代码对该Object是同步的,也就是说必须在作用等同于synchronized(obj){......}的内部才能够去调用obj的wait与notify/notifyAll三个方法,否则就会报错:

      java.lang.IllegalMonitorStateException: current thread not owner

      在调用wait的时候,线程自动释放其占有的对象锁,同时不会去申请对象锁。当线程被唤醒的时候,它才再次获得了去获得对象锁的权利。

      所以,notify与notifyAll没有太多的区别,只是notify仅唤醒一个线程并允许它去获得锁,notifyAll是唤醒所有等待这个对象的线程并允许它们去获得对象锁,只要是在synchronied块中的代码,没有对象锁是寸步难行的。其实唤醒一个线程就是重新允许这个线程去获得对象锁并向下运行。

       顺便说一下notifyall,虽然是对每个wait的对象都调用一次notify,但是这个还是有顺序的,每个对象都保存这一个等待对象链,调用的顺序就是这个链的顺序。其实启动等待对象链中各个线程的也是一个线程,在具体应用的时候,需要注意一下。

      网上找的一个实例:

package com.bijian.thread;

public class ThreadAttemper {
	
	public static void main(String[] args) {
		ThreadA a = new ThreadA();
		a.start();
		System.out.println("a is start....");
		synchronized (a) {
			try {
				System.out.println("Waiting for a to complete...");
				a.wait();
				System.out.println("a completed.Now back to main thread");
			} catch (InterruptedException e) {
			}
		}
		System.out.println("Total is :" + a.total);
	}
}

class ThreadA extends Thread {
	int total;
	public void run() {
		synchronized (this) {
			System.out.println("ThreadA is running..");
			for (int i = 0; i < 5; i++) {
				total += i;
				System.out.println("total is " + total);
			}
			notify();
		}
	}
}

       运行结果:

a is start....
ThreadA is running..
total is 0
total is 1
total is 3
total is 6
total is 10
Waiting for a to complete...

         发现程序在一直在a.wait();处,分析不难发现:ThreadA线程已运行结束,对于线程运行结束的对象,因其不可能再执行notify();从而激活主线程中的wait()方法,故一直停在这,不能往下执行。

      修改方法有两个:

      1.法一(不推荐):在ThreadA类的run方法中增加sleep方法,使主方法运行至a.wait();处时,ThreadA类的线程还未运行结束。如下所示:

package com.bijian.thread;

public class ThreadAttemper {
	
	public static void main(String[] args) {
		ThreadA a = new ThreadA();
		a.start();
		System.out.println("a is start....");
		synchronized (a) {
			try {
				System.out.println("Waiting for a to complete...");
				a.wait();
				System.out.println("a completed.Now back to main thread");
			} catch (InterruptedException e) {
			}
		}
		System.out.println("Total is :" + a.total);
	}
}

class ThreadA extends Thread {
	int total;
	public void run() {
		synchronized (this) {
			System.out.println("ThreadA is running..");
			for (int i = 0; i < 5; i++) {
				try {
					this.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				total += i;
				System.out.println("total is " + total);
			}
			notify();
		}
	}
}

       运行结果:

a is start....
Waiting for a to complete...
ThreadA is running..
total is 0
total is 1
total is 3
total is 6
total is 10
a completed.Now back to main thread
Total is :10

 

      2.法二(推荐):在main方法的a.wait()方法前增加判断,判断ThreadAA类的线程是否处于活动状态。如下所示:

package com.bijian.thread;

public class ThreadAttemper {
	
	public static void main(String[] args) {
		ThreadA a = new ThreadA();
		a.start();
		System.out.println("a is start....");
		synchronized (a) {
			try {
				System.out.println("Waiting for a to complete...");
				//测试线程是否处于活动状态
				if(a.isAlive()) {
					a.wait();
				}
				System.out.println("a completed.Now back to main thread");
			} catch (InterruptedException e) {
			}
		}
		System.out.println("Total is :" + a.total);
	}
}

class ThreadA extends Thread {
	int total;
	public void run() {
		synchronized (this) {
			System.out.println("ThreadA is running..");
			for (int i = 0; i < 5; i++) {
				total += i;
				System.out.println("total is " + total);
			}
			notify();
		}
	}
}

       运行结果:

a is start....
Waiting for a to complete...
ThreadA is running..
total is 0
total is 1
total is 3
total is 6
total is 10
a completed.Now back to main thread
Total is :10

 

 

        从上面的实例我们不难看到:“main()方法在子线程未执行结束时不会结束”。据此思想,我们可以扩展此实例,解决一些现实问题。如main方法启动多个线程依次做一些事情。

      扩展实例如下:

package com.bijian.thread;

public class ThreadAttemperA {
	
	public static void main(String[] args) {
		
		ThreadA a = new ThreadA();
		a.start();//启动a线程
		System.out.println("a is start....");
		synchronized (a) {
			try {
				System.out.println("Waiting for a to complete...");
				if(a.isAlive()) {
					a.wait();
				}
				System.out.println("a completed.Now back to main thread");
			} catch (InterruptedException e) {
			}
		}
		System.out.println("Total is :" + a.total);
		
		ThreadB b = new ThreadB();
		b.start();//启动b线程
		System.out.println("b is start....");
		synchronized (b) {
			try {
				System.out.println("Waiting for b to complete...");
				if(b.isAlive()) {
					b.wait();
				}
				System.out.println("b completed.Now back to main thread");
			} catch (InterruptedException e) {
			}
		}
		System.out.println("Total is :" + b.total);
	}
}

class ThreadA extends Thread {
	int total;
	public void run() {
		synchronized (this) {
			System.out.println("ThreadA is running..");
			for (int i = 0; i < 5; i++) {
				total += i;
				System.out.println("total is " + total);
			}
			notify();
		}
	}
}

class ThreadB extends Thread {
	int total;
	public void run() {
		synchronized (this) {
			System.out.println("ThreadB is running..");
			for (int i = 0; i < 10; i++) {
				total += i;
				System.out.println("total is " + total);
			}
			notify();
		}
	}
}

     运行结果:

a is start....
Waiting for a to complete...
ThreadA is running..
total is 0
total is 1
total is 3
total is 6
total is 10
a completed.Now back to main thread
Total is :10
b is start....
Waiting for b to complete...
ThreadB is running..
total is 0
total is 1
total is 3
total is 6
total is 10
total is 15
total is 21
total is 28
total is 36
total is 45
b completed.Now back to main thread
Total is :45

       从运行结果来看,虽有多个线程,但必须是第一个线程执行完成,再执行下一个线程,即是串行的。在串行的业务场景下,可以用此方法。

分享到:
评论

相关推荐

    java之wait,notify的用法([ 详解+实例 ])

    Java之wait和notify的用法详解 在Java多线程编程中,wait和notify是两个非常重要的方法,它们都是Object类的方法,用于线程之间的通信和同步。下面我们将详细解释wait和notify的用法。 wait方法 wait方法是Object...

    Java 同步方式 wait和notify/notifyall

    总结一下,`wait()`, `notify()`, 和 `notifyAll()` 是Java多线程编程中的核心工具,它们与`synchronized`关键字一起,为线程间的协作提供了强大的支持。理解并熟练掌握这些概念,对于编写高效、安全的多线程程序至...

    JAVAWAIT和NOTIFY的用法.pdf

    JAVAWAIT和NOTIFY的用法.pdf

    wait_notify_demo

    在Java中,`wait()`、`notify()`和`notifyAll()`方法都是与对象锁相关的,它们用于控制线程的同步。使用这些方法的前提是线程必须拥有对象的监视器,也就是对象锁。这是通过在synchronized块或方法中调用它们来实现...

    Java多线程wait和notify

    在Java中,`wait()` 和 `notify()` 方法是实现线程间通信和协作的重要工具,它们属于 `java.lang.Object` 类,这意味着所有类都默认继承了这两个方法。本文将详细探讨如何使用 `wait()` 和 `notify()` 来控制子线程...

    Java的sychronized、wait和notify范例

    `synchronized`关键字、`wait()`和`notify()`方法是Java多线程中用于控制并发访问共享资源的重要工具,它们是Java内存模型(JMM)的一部分,主要用于解决线程间的同步问题。 一、`synchronized`关键字 `...

    如何在Java中正确使用 wait, notify 和 notifyAll

     在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子,如果你的Java程序中有两个线程——即生产者和消费者,那么生产者可以通知消费者,让消费者开始消耗数据,因为队列缓冲区中有内容待...

    一个理解wait()与notify()的例子

    本文旨在解析一个具体的Java多线程示例代码,以帮助读者更好地理解`wait()`与`notify()`方法的作用及其实现机制。这两个方法是Java中实现线程间通信的重要手段之一,尤其在解决生产者消费者模型、读者写者问题等经典...

    浅谈java多线程wait,notify

    _java多线程wait、notify机制详解_ 在Java多线程编程中,wait和notify是两个非常重要的机制,用于实现线程之间的通信和同步。在本文中,我们将通过示例代码详细介绍Java多线程wait和notify的使用,帮助读者更好地...

    39.线程间的通信-wait与notify-wait方法自动释放锁与notify方法不会释放锁.mp4

    在学习Java过程中,自己收集了很多的Java的学习资料,分享给大家,有需要的欢迎下载,希望对大家有用,一起学习,一起进步。

    Java 同步锁 wait notify 学习心得

    `wait`和`notify`通常与条件变量模式结合使用,以实现线程之间的协调。例如,在生产者-消费者模型中,生产者线程在向共享缓冲区添加元素时可能会调用`wait()`,直到有空闲空间可用。消费者线程在移除元素后会调用`...

    Java多线程中wait、notify、notifyAll使用详解

    Java多线程中wait、notify、notifyAll使用详解 Java中多线程编程中,wait、notify、notifyAll三个方法是非常重要的,它们都是Object对象的方法,用于线程之间的通信。下面我们将详细介绍这三个方法的使用和作用。 ...

    java中几个notify、wait使用实例

    在Java的多线程编程中,`notify()`与`wait()`是实现线程间通信的重要方法,它们主要用于解决生产者消费者问题、读者写者问题等典型同步问题。这两个方法定义在`Object`类中,因此所有Java对象都可以作为锁来使用。在...

    主线程去控制子线程wait与notify

    在Java多线程编程中,`wait()`和`notify()`是两个非常重要的方法,它们用于线程间的协作和通信。这两个方法是Java语言中的Object类提供的,因此所有的对象都可以使用。在本文中,我们将深入探讨如何使用主线程来控制...

    源码—Java多线程5—死锁和wait notify notifyAll

    源码—Java多线程5—死锁和wait notify notifyAll

    详解Java程序并发的Wait-Notify机制

    Java程序并发的Wait-Notify机制是Java多线程编程中的一种重要同步工具,它允许线程之间通过共享对象进行通信和协作。这个机制基于Java的内置锁(也称为监视器锁),通常与`synchronized`关键字一起使用。在Java中,`...

    深入理解Wait、Notify和Wait与sleep区别

    本文将深入探讨`wait()`, `notify()`以及它们与`sleep()`方法的区别,这些都是Java中与线程同步密切相关的概念。 首先,`wait()`, `notify()`和`notifyAll()`是Object类中的方法,它们主要用于线程间通信和协作。...

    java-wait和notify的用法.pdf

    在Java编程语言中,`wait()`和`notify()`是Object类中的两个关键方法,它们用于线程间的协作和通信。这两个方法在多线程环境下尤其重要,因为它们允许线程等待特定条件并通知其他线程继续执行。在分析给定的程序之前...

    wait()、notify()和notifyAll()方法2---马克-to-win java视频

    wait()、notify()和notifyAll()方法2---马克-to-win java视频

    41.线程间的通信-wait与notify-只唤醒一个线程或所有线程.mp4

    在学习Java过程中,自己收集了很多的Java的学习资料,分享给大家,有需要的欢迎下载,希望对大家有用,一起学习,一起进步。

Global site tag (gtag.js) - Google Analytics