初探java 对象中wait(),notify(),notifyAll() 和线程中的synchronized
2014-11-02 16:25
513 查看
因为学习和兴趣需要,自学一点java的多进程,这两天好像刚刚明白了什么,一查博客,众说纷纭,有些越看越糊涂,所以想结合几篇自己认为还不错的博客,在这算是一个总结了。
首先,我们先谈谈wait(),notify()和notifyAll(),这三个方法呢,是定义在Object中的,而所有对象都继承了Object,所以呢,每个对象都能够调用他们。那么他们都是什么作用呢。
(你可以点开他官方文档,下面只做简单说明)
wait(): 他能阻塞当前线程,直至被notify()或者notifyAll()唤醒,或者是过一段特定的时间,才能再次开始运行.
notify():他能唤醒一个对象监视器(Object monitor)上一个被wait()阻塞的线程,这种唤醒是随机的发生的。
notifyAll():他能唤醒一个对象监视器(Object monitor)上等待的所有被wait()阻塞的线程。
以下内容基本来自于最简实例说明wait、notify、notifyAll的使用方法,我做了很多阉割,所以推荐看下原文。
我们可以看到结果:
Main thread run!
waiter0 begin waiting
waiter1 begin waiting
waiter2 begin waiting
waittime :3000
waiter0 end waiting!
对,很明显,只有一个线程被唤醒,其余两个仍旧在等待。因为在NotifyThread中,我们调用的是notify(),当我们把它换成notifyAll()呢。我们再看看结果:
Main thread run!
waiter0 begin waiting
waiter1 begin waiting
waiter2 begin waiting
waittime :3000
waiter2 end waiting!
waittime :3001
waiter1 end waiting!
waittime :3001
waiter0 end waiting!
这样一看就很清楚的知道差别了。好了,看了上面的程序,有一个细节不知道大家注意到了没。为什么我们synchronized (flag),而不是synchronized (this)呢?那么他们两者又有什么不同,synchronized又该如何使用呢。
下面内容参考:JAVA线程安全之synchronized关键字的正确用法,
Synchronized关键字总结
首先我们先看一段代码
在调用print1时,结果是12121212121212121212121212121212121212112121212121212121212121212121212121....当然每次结果不一定相同,但是都告诉我们一个道理,这样的同步就没达到我们的目的。
那我们运行print2,又会发生什么呢:11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222,这不正是我们想要的吗。为什么会这样的?且挺我慢慢道来。
我们先说说synchronized有两种用法:一呢,是同步方法;二呢,就是同步语句块了。
先说说同步方法的使用
这有两个同步方法,唯一不同的是修饰符的不同,第二个是静态,第二个则不是。他们有什么不同呢。首先,我们知道static方法是属于Class,而无static修饰呢,则属于一个具体的实例(Instance)。和之前类似,他们加的锁分别加到不同的对象上。而一个对象只能有一把锁。举例来说吧,我们依然用以上类,因为
我们创建了两个实例,而方法呢,是非static方法
所以呢,虽然使用了,synchronized关键字,但是,他只把锁加在实例中,而我们是创建了两个实例,因此,这锁相当于没加。那我们该怎么才能使这两个同步呢。我们可以采用以下方法:
1.
2.
这样之前的程序也就能正常运行了。
那么,我们要用synchronized语句块该怎么用呢。
在使用同步语句块时,我们得知道,synchronized()括号里加的什么就是对什么进行加锁。如synchronized(this),那就是对当前实例进行加锁.
好了那我们回归上面的问题。我们依然用那个实例进行举例。
假如我们的print2改为我现在改的样子,他还能成功吗?
答案很明显不能,因为他只是对当前实例进行加锁,我们的程序运行的是两个实例,所以根本就没有用。
所以,我们在编程中使用
或者是如我们最开始的那个类一样:
对synchronized(static 的 临界变量);如此以来,我们能保证所加的所是加在整个Class中,而不是单一的实例里。
文章可能有错,欢迎大家的批评改正。
首先,我们先谈谈wait(),notify()和notifyAll(),这三个方法呢,是定义在Object中的,而所有对象都继承了Object,所以呢,每个对象都能够调用他们。那么他们都是什么作用呢。
(你可以点开他官方文档,下面只做简单说明)
wait(): 他能阻塞当前线程,直至被notify()或者notifyAll()唤醒,或者是过一段特定的时间,才能再次开始运行.
notify():他能唤醒一个对象监视器(Object monitor)上一个被wait()阻塞的线程,这种唤醒是随机的发生的。
notifyAll():他能唤醒一个对象监视器(Object monitor)上等待的所有被wait()阻塞的线程。
以下内容基本来自于最简实例说明wait、notify、notifyAll的使用方法,我做了很多阉割,所以推荐看下原文。
package testthread; /** * Created by andrew on 14-10-30. */ public class NotifyWait { private String flag[] = {"true"}; class NotifyThread extends Thread{ public NotifyThread(String name) { super(name); } public void run() { try { sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (flag) { flag[0] = "false"; flag.notify(); } } } class WaitThread extends Thread{ public WaitThread(String name) { super(name); } public void run() { synchronized (flag) { while (flag[0] != "false") { System.out.println(getName() + " begin waiting"); long waittime = System.currentTimeMillis(); try { flag.wait(); } catch (InterruptedException e) { e.printStackTrace(); } waittime = System.currentTimeMillis() - waittime; System.out.println("waittime :" + waittime); } System.out.println(getName() + " end waiting!"); } } } public static void main(String[] args) { System.out.println("Main thread run!"); NotifyWait test = new NotifyWait(); NotifyThread notifythread = test.new NotifyThread("notify"); WaitThread waiter0 = test.new WaitThread("waiter0"); WaitThread waiter1 = test.new WaitThread("waiter1"); WaitThread waiter2 = test.new WaitThread("waiter2"); notifythread.start(); waiter0.start(); waiter1.start(); waiter2.start(); } }
我们可以看到结果:
Main thread run!
waiter0 begin waiting
waiter1 begin waiting
waiter2 begin waiting
waittime :3000
waiter0 end waiting!
对,很明显,只有一个线程被唤醒,其余两个仍旧在等待。因为在NotifyThread中,我们调用的是notify(),当我们把它换成notifyAll()呢。我们再看看结果:
Main thread run!
waiter0 begin waiting
waiter1 begin waiting
waiter2 begin waiting
waittime :3000
waiter2 end waiting!
waittime :3001
waiter1 end waiting!
waittime :3001
waiter0 end waiting!
这样一看就很清楚的知道差别了。好了,看了上面的程序,有一个细节不知道大家注意到了没。为什么我们synchronized (flag),而不是synchronized (this)呢?那么他们两者又有什么不同,synchronized又该如何使用呢。
下面内容参考:JAVA线程安全之synchronized关键字的正确用法,
Synchronized关键字总结
首先我们先看一段代码
package com; public class ThreadTest { public static void main(String[] args) { MyThread m1 = new MyThread(1); MyThread m2 = new MyThread(2); m1.start(); m2.start(); } } final class MyThread extends Thread { private int val; public MyThread(int v) { val = v; } //这种做法其实是非线程安全的 public synchronized void print1(int v) { for (int i = 0; i < 100; i++) { System.out.print(v); } } public void print2(int v) { //线程安全 synchronized (MyThread.class) { for (int i = 0; i < 100; i++) { System.out.print(v); } } } public void run() { print1(val); // print2(val); } }
在调用print1时,结果是12121212121212121212121212121212121212112121212121212121212121212121212121....当然每次结果不一定相同,但是都告诉我们一个道理,这样的同步就没达到我们的目的。
那我们运行print2,又会发生什么呢:11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222,这不正是我们想要的吗。为什么会这样的?且挺我慢慢道来。
我们先说说synchronized有两种用法:一呢,是同步方法;二呢,就是同步语句块了。
先说说同步方法的使用
public synchronized void methodA() { //code } public synchronized static void methodB() { //code }
这有两个同步方法,唯一不同的是修饰符的不同,第二个是静态,第二个则不是。他们有什么不同呢。首先,我们知道static方法是属于Class,而无static修饰呢,则属于一个具体的实例(Instance)。和之前类似,他们加的锁分别加到不同的对象上。而一个对象只能有一把锁。举例来说吧,我们依然用以上类,因为
<span style="white-space:pre"> </span>MyThread m1 = new MyThread(1); MyThread m2 = new MyThread(2); m1.start(); m2.start();
我们创建了两个实例,而方法呢,是非static方法
//这种做法其实是非线程安全的 public synchronized void print1(int v) { for (int i = 0; i < 100; i++) { System.out.print(v); } } public void print2(int v) { //线程安全 synchronized (MyThread.class) { for (int i = 0; i < 100; i++) { System.out.print(v); } }
所以呢,虽然使用了,synchronized关键字,但是,他只把锁加在实例中,而我们是创建了两个实例,因此,这锁相当于没加。那我们该怎么才能使这两个同步呢。我们可以采用以下方法:
1.
<span style="white-space:pre"> </span>MyThread m1 = new MyThread(1); Thread demo1 = new Thread(m1, "abc"); Thread demo2 = new Thread(m1, "ert"); demo1.start(); demo2.start();
2.
public synchronized static void print1(int v) { for (int i = 0; i < 10; i++) { System.out.println(this.currentThread().getName()); } }
这样之前的程序也就能正常运行了。
那么,我们要用synchronized语句块该怎么用呢。
在使用同步语句块时,我们得知道,synchronized()括号里加的什么就是对什么进行加锁。如synchronized(this),那就是对当前实例进行加锁.
好了那我们回归上面的问题。我们依然用那个实例进行举例。
假如我们的print2改为我现在改的样子,他还能成功吗?
public void print2(int v) { synchronized (this) { for (int i = 0; i < 100; i++) { System.out.print(v); } } }
答案很明显不能,因为他只是对当前实例进行加锁,我们的程序运行的是两个实例,所以根本就没有用。
所以,我们在编程中使用
public void print2(int v) { synchronized (this.class) { for (int i = 0; i < 100; i++) { System.out.print(v); } } }
或者是如我们最开始的那个类一样:
synchronized (flag) { while (flag[0] != "false") { System.out.println(getName() + " begin waiting"); long waittime = System.currentTimeMillis(); try { flag.wait(); } catch (InterruptedException e) { e.printStackTrace(); } waittime = System.currentTimeMillis() - waittime; System.out.println("waittime :" + waittime); } System.out.println(getName() + " end waiting!"); }
对synchronized(static 的 临界变量);如此以来,我们能保证所加的所是加在整个Class中,而不是单一的实例里。
文章可能有错,欢迎大家的批评改正。
相关文章推荐
- JAVA 线程状态以及synchronized,wait,sleep,yield,notify,notifyAll
- java线程通讯——使用Lock和Condition代替synchronized 和 wait, notify notifyAll()
- java线程通讯——使用Lock和Condition代替synchronized 和 wait, notify notifyAll()
- java线程通讯——使用Lock和Condition代替synchronized 和 wait, notify notifyAll()
- 线程问题3(synchronized,wait,notify,notifyAll,类锁,对象锁)
- JAVA 线程状态以及synchronized,wait,sleep,yield,notify,notifyAll
- JAVA线程状态以及synchronized,wait,sleep,yield,notify,notifyAll
- java线程通讯——使用Lock和Condition代替synchronized 和 wait, notify notifyAll()
- Java线程和多线程(二)——对象中的wait,notify以及notifyAll方法
- Java线程和多线程(二)——对象中的wait,notify以及notifyAll方法
- java线程同步(synchronized,wait,notify,notifyAll)
- Java中的synchronized、Object.wait()、Object.notify()/notifyAll()原理
- java线程wait、notify、notifyAll
- java多线程设计wait/notify机制 (synchronized与对象锁)
- Java线程中sleep()、wait()和notify()和notifyAll()、yield()、join()等方法的用法和区别
- 关于java中的synchronized、wait以及notify和notifyAll
- Java中级----多线程同步基本思想,java多线程设计wait、notify、notifyall、synchronized的使用机制(转)
- Java线程中sleep()、wait()和notify()和notifyAll()、yield()、join()等方法的用法和区别
- Java线程中sleep()、wait()和notify()和notifyAll()、yield()、join()等方法的用法和区别
- Java线程中sleep()、wait()和notify()和notifyAll()、yield()、join()等方法的用法和区别