java wait和notify及 synchronized sleep 总结
java 中线程我一直弄不清线程锁等
所以写了一些例子验证看法：
在这之前先看下API中wait中的解释:
wait：方法来之java.lang.Objetc
方法翻译：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。并释放所有同步锁 //当前线程必须拥有此对象监视器。 （sleep不会释放）
sleep:休眠当前线程 并且不释放同步锁
notify:唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个
wait 方法，在对象的监视器上等待。该方法不会释放调用线程的同步锁
synchronized：当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块
那么实验1:
大家看到线程A B C分别锁了 Test中 s1 s2 s3
猜想：因为s1 s2 s3 不是同一对象所以会交替打印 我是线程A 线程B 线程C
package com.fmy.test;
public class Test {
static String s1 ="";
static String s2 ="";
static String s3 ="";
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
c.start();
b.start();
a.start();
}
}
class A extends Thread{
@Override
public void run() {
synchronized (Test.s1) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程A");
}
}
}
}
class B extends Thread{
@Override
public void run() {
synchronized (Test.s2) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程B");
}
}
}
}
class C extends Thread{
@Override
public void run() {
synchronized (Test.s3) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程C");
}
}
}
}
输出结果:
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
结果发现打印的是 全是 线程C
原因 S1 S2 S3指向同一常量池 所以锁的是同一内存区 所以 static String s1 =new String() static String s2 =new String()
static String s3 =new String() 的时候他们会交替打印
那么实验2:
package com.fmy.test;
public class Test {
static String s1 =new String();
static String s2 =new String();
static String s3 =new String();
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
c.start();
b.start();
a.start();
}
}
class A extends Thread{
@Override
public void run() {
synchronized (Test.s1) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程A");
}
}
}
}
class B extends Thread{
@Override
public void run() {
synchronized (Test.s2) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程B");
}
}
}
}
class C extends Thread{
@Override
public void run() {
synchronized (Test.s3) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程C");
}
}
}
}
输出结果：
我是线程A
我是线程C
我是线程B
我是线程A
我是线程C
我是线程B
我是线程A
我是线程C
我是线程B
我是线程A
我是线程C
我是线程A
我是线程B
我是线程C
我是线程B
我是线程A
结论：证明实验一结论是正确的
实验三：
wait是否要在synchronized方法块中？
public class Test {
static String s1 =new String();
static String s2 =new String();
static String s3 =new String();
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
a.start();
}
}
class A extends Thread{
@Override
public void run() {
// synchronized (Test.s1) {
while (true) {
try {
Test.s1.wait();
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程A");
}
// }
}
输出结果:异常
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Unknown Source)
at com.fmy.test.A.run(Test.java:22)
结论： wait是要在synchronized方法块中
实验四： notify是否要在synchronized方法块中
与实验三差不多 所以不贴出代码
结果:notify是否要在synchronized方法块中
实验五：
某个线程没有X的对象锁调用 X.WAIT() 是否会让该对象阻塞 或者其他拥有 X对象锁的线程阻塞
package com.fmy.test;
public class Test {
static String s1 =new String();
static String s2 =new String();
static String s3 =new String();
static String s4 =new String();
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
a.start();
b.start();
}
}
class A extends Thread{
@Override
public void run() {
synchronized (Test.s4) {
while (true) {
try {
Test.s2.wait();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程A");
}
}
}
}
class B extends Thread{
@Override
public void run() {
synchronized (Test.s2) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程B");
}
}
}
}
输出结果：java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Unknown Source)
at com.fmy.test.A.run(Test.java:24)
java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Unknown Source)
at com.fmy.test.A.run(Test.java:24)
我是线程A
我是线程B
我是线程B
我是线程A
java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Unknown Source)
at com.fmy.test.A.run(Test.java:24)
我是线程A
我是线程B
我是线程B
我是线程A
结论：不能锁住当前线程和其他拥有该对象锁的线程并且会报异常
所以：当你想阻塞某个线程的时候请在某个线程中调用wait方法 并且对象拥有该锁
实验六：
某个线程没有X对象锁调用notify（）可以唤醒其他被锁的对象吗？
package com.fmy.test;
public class Test {
static String s1 =new String();
static String s2 =new String();
static String s3 =new String();
static String s4 =new String();
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
a.start();
b.start();
}
}
class A extends Thread{
@Override
public void run() {
synchronized (Test.s4) {
while (true) {
try {
sleep(1000);
Test.s2.notify();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程A");
}
}
}
}
class B extends Thread{
@Override
public void run() {
synchronized (Test.s2) {
try {
Test.s2.wait();
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程B");
}
}
}
}
输出结果：java.lang.IllegalMonitorStateException
at java.lang.Object.notify(Native Method)
at com.fmy.test.A.run(Test.java:25)
我是线程A
java.lang.IllegalMonitorStateException
at java.lang.Object.notify(Native Method)
at com.fmy.test.A.run(Test.java:25)
我是线程A
java.lang.IllegalMonitorStateException
at java.lang.Object.notify(Native Method)
at com.fmy.test.A.run(Test.java:25)
我是线程A
结论：一个对象没有X的对象锁使用了notify将不会唤醒其他线程使用了X.wait导致的阻塞
实验七：wait会是释放线所有该线程占有的锁吗？
<pre name="code" class="java">package com.fmy.test;
public class Test {
static String s1 =new String();
static String s2 =new String();
static String s3 =new String();
static String s4 =new String();
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
a.start();
b.start();
}
}
class A extends Thread{
@Override
public void run() {
synchronized (Test.s2) {
synchronized (Test.s1) {
while (true) {
try {
System.out.println("我是A让自己阻塞");
Test.s2.wait();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程A");
}
}
}
}
}
class B extends Thread{
@Override
public void run() {
synchronized (Test.s2) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程B");
}
}
}
}
输出结果：我是A让自己阻塞
我是线程B
我是线程B
我是线程B
我是线程B
结论：wait方法会释放线程的所有同步锁
实验八：sleep会是释放线所有该线程占有的锁吗？
package com.fmy.test;
public class Test {
static String s1 =new String();
static String s2 =new String();
static String s3 =new String();
static String s4 =new String();
public static void main(String[] args) {
A a = new A();
B b = new B();
C c = new C();
a.start();
b.start();
}
}
class A extends Thread{
@Override
public void run() {
synchronized (Test.s2) {
synchronized (Test.s1) {
while (true) {
try {
System.out.println("我是A让自己睡一下");
sleep(1000);
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程A");
}
}
}
}
}
class B extends Thread{
@Override
public void run() {
synchronized (Test.s2) {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程B");
}
}
}
}
输出结果：我是A让自己睡一下
我是线程A
我是A让自己睡一下
我是线程A
我是A让自己睡一下
我是线程A
我是A让自己睡一下
结论：sleep方法不会释放调用线程的同步锁
实验九：证明 和理解 notify():该方法不会释放调用线程的同步锁,只是会唤醒被wait()阻塞的线程
<span style="color:#000000;">package com.fmy.test;
public class Test {
static String s1 =new String();
static String s2 =new String();
static String s3 =new String();
static String s4 =new String();
static A a = null;
public static void main(String[] args) {
a = new A();
B b = new B();
C c = new C();
a .start();
b.start();
}
}
class A extends Thread{
@Override
public void run() {
synchronized (Test.s1) {
System.out.println("我是A让自己阻塞");
try {
Test.s1.wait();
} catch (InterruptedException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
}
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("我是线程A");
}
}
}
}
class B extends Thread{
@Override
public void run() {
synchronized (Test.s1) {
while (true) {
try {
sleep(1000);//保证线程A先执行 到wait处
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("被阻塞后的A线程状态"+Test.a.getState());
System.out.println("我是线程B");
//唤醒A线程
Test.s1.notify();
System.out.println("被唤醒线程A的状态"+Test.a.getState());
}
}
}
}</span>
输出结果：我是A让自己阻塞
被阻塞后的A线程状态WAITING
我是线程B
被唤醒线程A的状态BLOCKED
被阻塞后的A线程状态BLOCKED
我是线程B
被唤醒线程A的状态BLOCKED
被阻塞后的A线程状态BLOCKED
我是线程B
结论：证实实验九。直到调用notify的线程结束或者自行放弃同步锁才能到被唤醒的线程执行。notify方法只会唤醒被阻塞的线程而已 并不会影响到调用此方法的线程所有状态和锁
java wait和notify及 synchronized sleep 总结的更多相关文章
- 转：JAVA 的wait(), notify()与synchronized同步机制
原文地址:http://blog.csdn.net/zyplus/article/details/6672775 转自:https://www.cnblogs.com/x_wukong/p/40097 ...
- JAVA 的wait(), notify()与synchronized同步机制
转自:http://blog.csdn.net/zyplus/article/details/6672775 在JAVA中,是没有类似于PV操作.进程互斥等相关的方法的.JAVA的进程同步是通过syn ...
- java锁——wait，notify，synchronized
背景:这篇博客用来总结java锁相关的知识点,平时还是要自己多加练习 wait 和 notify以及notifyAll (1).方法介绍1.wait.notify以及notifyAll都是Object ...
- Java Thread wait, notify and notifyAll Example
Java Thread wait, notify and notifyAll Example Java线程中的使用的wait,notify和nitifyAll方法示例. The Object clas ...
- java wait()和notify()、notifyAll()
图见<JAVA并发编程的艺术>P98-101 这三个方法都是java.lang.Object的方法,用于协调多个线程对共享数据的存取,必须在synchronized语句块中使用!这三个方法 ...
- [译]Java Thread wait, notify和notifyAll示例
Java Thread wait, notify和notifyAll示例 Java上的Object类定义了三个final方法用于不同线程间关于某资源上的锁状态交互,这三个方法是:wait(), not ...
- Java的wait(), notify()和notifyAll()使用心得（转）
本篇文章是对java的 wait(),notify(),notifyAll()进行了详细的分析介绍,需要的朋友参考下wait(),notify()和notifyAll()都是java.lang.Obj ...
- Java使用wait() notify()方法操作共享资源
Java多个线程共享资源: 1)wait().notify()和notifyAll()方法是本地方法,并且为final方法,无法被重写. 2)调用某个对象的wait()方法能让当前线程阻塞,并且当前线 ...
- C# 实现java中 wiat/notify机制
最近在学习java,看到wiat/notify机制实现线程通信,由于平时工作用的C#,赶紧用C#方式实现一个demo. Java 代码: import java.util.ArrayList; imp ...
随机推荐
- SpringBoot添加自定义拦截器
拦截器的主要作用是拦截用户的请求并做相应的处理,如判断用户是否登录,用户是否具有操作权限等等. 实现 HandlerInterceptor 接口来拦截请求 public class MyInterce ...
- mysql中binlog与存储引擎的2PC
mysql内部的2PC mysql开启binlog后实际上可以认为其数据有两份,binlog中一份,引擎中一份(这里先把存储引擎中数据看成整体的单独一份,另外也可以把binlog看成是一个引擎).既然 ...
- 一款基于Vue的扩展性组件库 VV-UI
github: https://github.com/VV-UI/VV-UI 演示地址: https://vv-ui.github.io/VV-UI/#/meta-info 1. LoadingBar ...
- MYSQL 表左连接 ON AND 和ON WHERE 的区别
首先是针对左右连接,这里与inner join区分 在使用left join时,on and 和on where会有区别 1. on的条件是在连接生成临时表时使用的条件,以左表为基准 ,不管on中的条 ...
- oss web直传
签名信息 auth.php <?php function gmt_iso8601($time) { $dtStr = date("c", $time); $mydatetim ...
- iOS开发-文件管理
iOS学习笔记(十七)--文件操作(NSFileManager) 浅析 RunLoop 解决EXC_BAD_ACCESS错误的一种方法--NSZombieEnabled iOS开发--Swift篇&a ...
- 03_OGNL
1.值栈: 解答Struts能够直接获取属性值: 原因:Struts并不是直接通过request隐式对象中获取,而是将整个对象封装到了ValueStack值栈中,直接匹配是否存在这个属性,找到了就取出 ...
- MySQL 字符串截取SUBSTRING()函数
MySQL 字符串截取相关函数: 1.从左开始截取字符串 left(str, length) 说明:left(被截取字段,截取长度) 例: select left(content,200) as ab ...
- Sharding-jdbc实现分库分表
首先在pom文件中引入需要的依赖 <dependency> <groupId>io.shardingjdbc</groupId> <artifactId> ...
- SpringMVC总结(SSM)
Day1 1. springMvc:是一个表现层框架: 作用:就是从请求中接收传入的参数, 将处理后的结果数据返回给页面展示2. ssm整合: 1)Dao层 pojo和映射文件以及接口手动编写(或使用 ...