java 中关于synchronized的通常用法
package j2se.thread.test; /***
* synchronized(class)很特别，它会让另一个线程在任何需要获取class做为monitor的地方等待．
* class与this做为不同的监视器可以同时使用，不存在一个线程获取了class，另一个线程就不能获取该class的一切实例．
根据下面的代码自行修改,分别验证下面的几种情况：
synchronized(class)
synchronized(this)
－＞线程各自获取monitor，不会有等待．
synchronized(this)
synchronized(this)
－＞如果不同线程监视同一个实例对象，就会等待，如果不同的实例，不会等待．
synchronized(class)
synchronized(class)
－＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
*/ /**
* @author liwei
测试synchronized(this)与synchronized(class)
*/
public class TestSynchronied8 {
private static byte[] lockStatic = new byte[0]; // 特殊的instance变量
private byte[] lock = new byte[0]; // 特殊的instance变量 public synchronized void m4t5() {
System.out.println(this);
int i = 50;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(100);
} catch (InterruptedException ie) {
}
Thread.yield();
}
} public void m4t0() {
synchronized(this) {
System.out.println(this);
int i = 50;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(100);
} catch (InterruptedException ie) {
}
Thread.yield();
}
}
} public void m4t1() {
synchronized(lock) {
System.out.println(this);
int i = 50;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(100);
} catch (InterruptedException ie) {
}
Thread.yield();
}
}
}
/**
* synchronized(class)
synchronized(class)
－＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
*/
public static synchronized void m4t2() {
int i = 50;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(100);
} catch (InterruptedException ie) {
}
Thread.yield(); }
} public static void m4t3() {
synchronized(TestSynchronied8.class){
int i = 50;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(100);
} catch (InterruptedException ie) {
}
Thread.yield();
}
}
} public static void m4t4() {
synchronized(lockStatic){
int i = 50;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(100);
} catch (InterruptedException ie) {
}
Thread.yield();
}
}
} /**
synchronized(this)
synchronized(this)
－＞如果不同线程监视不同的实例，不会等待．
*/
public static void testObjsyn1(){
final TestSynchronied8 myt2 = new TestSynchronied8();
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
System.out.println("测试两个不同的对象上，运行同一个synchronized（this）代码块-------------------------------------");
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t1 = new Thread( new Runnable() { public void run() { myt1.m4t0(); } }, "t1" );
Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t0(); } }, "t2" );
t1.start();
t2.start();
} /**
synchronized(this)
synchronized(this)
－＞如果不同线程监视同一个实例，会等待．
*/
public static void testObjsyn2(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
System.out.println("测试一个对象上，运行同一个synchronized（this）代码块-------------------------------------");
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t3 = new Thread( new Runnable() { public void run() { myt1.m4t0(); } }, "t3" );
Thread t4 = new Thread( new Runnable() { public void run() { myt1.m4t0(); } }, "t4" );
t3.start();
t4.start();
} /**
synchronized(this)
synchronized(this)
－＞如果不同线程监视同一个实例，会等待．
*/
public static void testObjsyn3(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
System.out.println("测试一个对象上，运行同一个synchronized(obj)代码块-------------------------------------");
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t5 = new Thread( new Runnable() { public void run() { myt1.m4t1(); } }, "t5" );
Thread t6 = new Thread( new Runnable() { public void run() { myt1.m4t1(); } }, "t6" );
t5.start();
t6.start();
} /**
synchronized(this)
synchronized(this)
－＞如果不同线程监视同一个实例，会等待．
*/
public static void testObjsyn4(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
System.out.println("测试一个对象上，运行同一个synchronized方法-------------------------------------");
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t7 = new Thread( new Runnable() { public void run() { myt1.m4t5(); } }, "t7" );
Thread t8 = new Thread( new Runnable() { public void run() { myt1.m4t5(); } }, "t8" );
t7.start();
t8.start();
} /**
synchronized(this)
synchronized(this)
－＞如果不同线程监视不同的实例，不会等待．
*/
public static void testObjsyn5(){
final TestSynchronied8 myt1 = new TestSynchronied8();
final TestSynchronied8 myt2 = new TestSynchronied8();
try {
System.out.println("测试两个不同对象上，运行同一个synchronized方法-------------------------------------");
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t9 = new Thread( new Runnable() { public void run() { myt1.m4t5(); } }, "t9" );
Thread t10 = new Thread( new Runnable() { public void run() { myt2.m4t5(); } }, "t10" );
t9.start();
t10.start();
} /**
synchronized(this)
synchronized方法
－＞如果不同线程监视同一实例，一个是syschronized（this），一个是同步方法，会等待．
*/
public static void testObjsyn6(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t9 = new Thread( new Runnable() { public void run() { myt1.m4t0(); } }, "t9" );
Thread t10 = new Thread( new Runnable() { public void run() { myt1.m4t5(); } }, "t10" );
t9.start();
t10.start();
} /**
synchronized(lock)
synchronized方法
－＞如果不同线程监视同一实例，一个是syschronized（lock），一个是同步方法，不会等待．
*/
public static void testObjsyn7(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t9 = new Thread( new Runnable() { public void run() { myt1.m4t1(); } }, "t9" );
Thread t10 = new Thread( new Runnable() { public void run() { myt1.m4t5(); } }, "t10" );
t9.start();
t10.start();
} /**
synchronized(lock)
synchronized方法
－＞如果不同线程监视同一实例，一个是syschronized（lock），一个是syschronized（this），不会等待．
*/
public static void testObjsyn71(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t9 = new Thread( new Runnable() { public void run() { myt1.m4t0(); } }, "t9" );
Thread t10 = new Thread( new Runnable() { public void run() { myt1.m4t1(); } }, "t10" );
t9.start();
t10.start();
} /**
* synchronized(class)
synchronized(class)
－＞如果不同线程监视不同的实例对象，会等待．
*/
public static void testObjsyn8(){
final TestSynchronied8 myt1 = new TestSynchronied8();
final TestSynchronied8 myt2 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, "t2" );
Thread t4 = new Thread( new Runnable() { public void run() { myt1.m4t2(); } }, "t4" );
t2.start();
t4.start();
} /**
* synchronized(class)
synchronized(class)
－＞如果不同线程监视同一的实例对象，会等待．
*/
public static void testObjsyn9(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t2 = new Thread( new Runnable() { public void run() { myt1.m4t2(); } }, "t2" );
Thread t4 = new Thread( new Runnable() { public void run() { myt1.m4t2(); } }, "t4" );
t2.start();
t4.start();
} /**
* synchronized(class)
synchronized(this)
－＞线程各自获取monitor，不会有等待．
*/
public static void testObjsyn10(){
final TestSynchronied8 myt1 = new TestSynchronied8();
final TestSynchronied8 myt2 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t7 = new Thread( new Runnable() { public void run() { myt2.m4t0(); } }, "t7" );
Thread t8 = new Thread( new Runnable() { public void run() { myt1.m4t3(); } }, "t8" );
t7.start();
t8.start();
} /**
* synchronized(class)
synchronized(this)
－＞线程各自获取monitor，不会有等待．
*/
public static void testObjsyn11(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t7 = new Thread( new Runnable() { public void run() { myt1.m4t0(); } }, "t7" );
Thread t8 = new Thread( new Runnable() { public void run() { myt1.m4t3(); } }, "t8" );
t7.start();
t8.start();
} /**
* synchronized(class)
synchronized(lock)
－＞线程各自获取monitor，不会有等待．
*/
public static void testObjsyn12(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t7 = new Thread( new Runnable() { public void run() { myt1.m4t1(); } }, "t7" );
Thread t8 = new Thread( new Runnable() { public void run() { myt1.m4t3(); } }, "t8" );
t7.start();
t8.start();
} /**
* synchronized(class)
synchronized(lockStatic)
－＞线程各自获取monitor，不会有等待．
*/
public static void testObjsyn13(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t7 = new Thread( new Runnable() { public void run() { myt1.m4t4(); } }, "t7" );
Thread t8 = new Thread( new Runnable() { public void run() { myt1.m4t3(); } }, "t8" );
t7.start();
t8.start();
} /**
* synchronized方法
synchronized(lockStatic)
－＞线程各自获取monitor，不会有等待．
*/
public static void testObjsyn14(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t7 = new Thread( new Runnable() { public void run() { myt1.m4t4(); } }, "t7" );
Thread t8 = new Thread( new Runnable() { public void run() { myt1.m4t2(); } }, "t8" );
t7.start();
t8.start();
} /**
* synchronized方法
synchronized(lockStatic)
－＞线程各自获取monitor，不会有等待．
*/
public static void testObjsyn15(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t7 = new Thread( new Runnable() { public void run() { myt1.m4t3(); } }, "t7" );
Thread t8 = new Thread( new Runnable() { public void run() { myt1.m4t2(); } }, "t8" );
t7.start();
t8.start();
} /**
* synchronized方法
synchronized(lockStatic)
－＞线程各自获取monitor，不会有等待．
*/
public static void testObjsyn16(){
final TestSynchronied8 myt1 = new TestSynchronied8();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t7 = new Thread( new Runnable() { public void run() { myt1.m4t1(); } }, "t7" );
Thread t8 = new Thread( new Runnable() { public void run() { myt1.m4t4(); } }, "t8" );
t7.start();
t8.start();
} /**
* synchronized(class)和static synchronized 方法所获取的锁是一样的
* synchronized(class)方法和静态的方法中的 synchronized(lockStatic)代码块获取的锁是不一样的
* 非静态的方法中的synchronized(this)代码块和非静态的 synchronized 方法所获取的锁是一样的
* (静态和非静态) synchronized(this)和(静态和非静态)的 synchronized(lock)代码块获取的锁是不一样的
*
* 总的来说synchronized(class)和static synchronized 方法获取的是类锁
* 非静态的方法中的synchronized(this)代码块和非静态的 synchronized 方法所获取的锁是类的实例的对象锁
* synchronized(lockStatic)获取的是静态属性的锁
* synchronized(lock) 获取的是非静态属性的锁
* 如果获取的锁是一样的，代码就会同步 ；锁不一样就不会同步
*/
public static void main(String[] args) {
//对于非静态的方法，同步方法和 synchronized(this) 获取的是实例对象锁
//对于非静态的方法，同步方法和 synchronized(lock) 获取的锁的lock // testObjsyn1();//如果不同线程监视不同的实例，不会等待． synchronized(this)
// testObjsyn2();//如果不同线程监视同一个实例，会等待． synchronized(this)
// testObjsyn3();//如果不同线程监视同一个实例，会等待． synchronized(lock)
// testObjsyn4();//如果不同线程监视同一个实例，会等待． synchronized 方法
// testObjsyn5();//如果不同线程监视不同的实例，不会等待． synchronized 方法
// testObjsyn6();//如果不同线程监视同一实例，一个是syschronized（this），一个是同步方法，会等待
// testObjsyn7(); //如果不同线程监视同一实例，一个是syschronized（lock），一个是同步方法，不会等待，锁定的对象不一样的
// testObjsyn71(); //如果不同线程监视同一实例，一个是syschronized（lock），一个是syschronized（this），不会等待，锁定的对象不一样的 /**
* synchronized(class)
synchronized(class)
－＞如果不同线程监视同一个实例或者不同的实例对象，都会等待．
*/
// testObjsyn8();//如果不同线程监视不同的实例对象，会等待．synchronized(class)
// testObjsyn9();//如果不同线程监视同一的实例对象，会等待．synchronized(class)
// testObjsyn10();//如果不同线程监视不同的实例对象，不会等待．synchronized(class)，synchronized(this)
// testObjsyn11();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(this)
// testObjsyn12();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(lock)
// testObjsyn13();//如果不同线程监视同一的实例对象，不会等待．synchronized(class)，synchronized(lockStatic)
// testObjsyn14();//如果不同线程监视同一的实例对象，不会等待．synchronized()方法，synchronized(lockStatic)
// testObjsyn15();//如果不同线程监视同一的实例对象，会等待．synchronized()方法，synchronized(class)
// testObjsyn16();//如果不同线程监视同一的实例对象，不会等待．synchronized(lock)方法，synchronized(lockStatic) }
}
java 中关于synchronized的通常用法的更多相关文章
- 巨人大哥谈Java中的Synchronized关键字用法
巨人大哥谈Java中的Synchronized关键字用法 认识synchronized 对于写多线程程序的人来说,经常碰到的就是并发问题,对于容易出现并发问题的地方价格synchronized基本上就 ...
- JAVA中字符串函数subString的用法小结
本篇文章主要是对JAVA中字符串函数subString的用法进行了详细的介绍,需要的朋友可以过来参考下,希望对大家有所帮助 String str; str＝str.substring(int begi ...
- 【Java学习笔记之二十九】Java中的"equals"和"=="的用法及区别
Java中的"equals"和"=="的用法及区别 在初学Java时,可能会经常碰到下面的代码: String str1 = new String(" ...
- java中 this 的三种用法
Java中this的三种用法 调用属性 (1)this可以调用本类中的任何成员变量 调用方法(可省略) (2)this调用本类中的成员方法(在main方法里面没有办法通过this调用) 调用构造方法 ...
- Java中枚举的写法和用法
在公司代码中,用了一大堆的枚举,看得我好懵逼.下面开始看看枚举怎么写和怎么用. 一.枚举的写法 关于枚举的写法,网上好多这方面的知识.这里直接贴一个我自己写的枚举类的代 ...
- Java中try,catch,finally的用法
Java中try,catch,finally的用法,以前感觉还算熟悉,但看到一篇博文才有更深点的理解,总结网友博客如下. Java异常处理的组合方式: 1.try+catch 运行流程:运行到try ...
- 对kotlin和java中的synchronized的浅谈
synchronized在java中是一个关键字,但是在kotlin中是一个内联函数.假如分别在java和kotlin代码锁住同一个对象,会发生什么呢,今天写了代码试了试.首先定义people类 12 ...
- Java中的Synchronized关键字用法
认识synchronized 对于写多线程程序的人来说,经常碰到的就是并发问题,对于容易出现并发问题的地方加上synchronized修饰符基本上就搞定 了,如果说不考虑性能问题的话,这一招绝对能应对 ...
- 深入理解java中的synchronized关键字
synchronized 关键字,代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B(或者C D等),有的话要等正在使用这个方法的线程B(或者C D ...
随机推荐
- 28.zookeeper单机(Standalones模式)和集群搭建笔记
zookeeper单机(Standalones模式)和集群搭建: 前奏: (1).zookeeper也可以在windows下使用,和linux一样可以单机也可以集群,具体就是解压zookeeper-3 ...
- 微信iphone7、 ios10播放视频解决方案 2016.11.10
2016.11.10日更新以下方法 微信最新出同层播放规范 即使是官方的也无法解决所有android手机的问题. 另外iphone 5 .5s 某些手机始终会弹出播放,请继续采用 “以下是老的解决办法 ...
- left和offsetLeft
left: 1.当该对象的定位position为absolute时left是相对于拥有定位属性(position的值为默认值"static"时除外)的父级对象的左边距. 例1:当父 ...
- [地图SkyLine二次开发]框架(5)完结篇
上节讲到,将菜单悬浮到地图上面,而且任何操作都不会让地图把菜单盖住. 这节带大家,具体开发一个简单的功能,来了进一步了解,这个框架. 1.想菜单中添加按钮 -上节定义的mainLayout.js文件里 ...
- String or binary data would be truncated 解决办法
原因: 一般出现这个问题是因为数据库中的某个字段的长度小,而插入数据大 解决: 找到相应字段,修改表结构,使表字段大小相同或大于要插入的数据
- js函数前面写上分号的原因
说个之前先说,网站上传一些文件,考虑到性能问题,会用一些压缩软件来压缩代码(grunt,glup,webpack,etc..),这时候就可能出现一个问题.看下面代码 (function a(){... ...
- LoadRunner脚本参数化设置
LoadRunner,是一种预测系统行为和性能的负载测试工具,其中VUG(Virtual User Generator)主要用于虚拟用户生成和脚本编辑.为了实现单用户多次迭代执行脚本,VUG提供了强大 ...
- ExtJS自制表格Grid分页条
试过Grid自带的load和分页功能,没有成功,干脆就自己写了...... 主要是查询条件比较复杂...... 希望哪位大神能有更好的意见. Ext.define('MyApp.ux.Paginati ...
- 对HTML5校验 自定义验证信息
在HTML5中,表单可以定义一个属性required来触发默认的校验机制,比如: <input type="text" required /> 弹出的错误提示默认为英文 ...
- DEVExpress GridControl|TableView |FormatConditions 按一定格式设置相应内容
Get到一个新技能,感觉好棒.摘自DEV官网:https://www.devexpress.com/Support/Center/Example/Details/T135593 <Window ...