synchronized(this)、synchronized(class)与synchronized(Object)的区别

最新推荐文章于 2022-08-23 16:17:17 发布
最新推荐文章于 2022-08-23 16:17:17 发布
阅读量118 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/lsl1991/blog/1581665
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

在多线程开发中，我们经常看到synchronized(this)、synchronized(*.class)与synchronized(任意对象)这几种类型同步方法。但是是否知道这几种写法有什么区别了？下面根据代码来分析：

 

synchronized代码块间的同步性

 

[java] view plain copy

  1. package com.zwz.thread.demo1;  
  2.   
  3. public class ObjectService {  
  4.     public void serviceMethodA(){  
  5.         try {  
  6.             synchronized (this) {  
  7.                 System.out.println("A begin time="+System.currentTimeMillis());  
  8.                 Thread.sleep(2000);  
  9.                 System.out.println("A end   time="+System.currentTimeMillis());  
  10.             }  
  11.         } catch (InterruptedException e) {  
  12.             e.printStackTrace();  
  13.         }  
  14.     }  
  15.     public void serviceMethodB(){  
  16.         synchronized (this) {  
  17.             System.out.println("B begin time="+System.currentTimeMillis());  
  18.             System.out.println("B end   time="+System.currentTimeMillis());  
  19.         }  
  20.     }  
  21. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo1;  
  2.   
  3. public class ThreadA extends Thread {  
  4.     private ObjectService objectService;  
  5.     public ThreadA(ObjectService objectService){  
  6.         super();  
  7.         this.objectService=objectService;  
  8.     }  
  9.     @Override  
  10.     public void run() {  
  11.         super.run();  
  12.         objectService.serviceMethodA();  
  13.     }  
  14. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo1;  
  2.   
  3. public class ThreadB extends Thread {  
  4.     private ObjectService objectService;  
  5.     public ThreadB(ObjectService objectService){  
  6.         super();  
  7.         this.objectService=objectService;  
  8.     }  
  9.     @Override  
  10.     public void run() {  
  11.         super.run();  
  12.         objectService.serviceMethodB();  
  13.     }  
  14. }  

 

 

[java] view plain copy

  1. package com.zwz.thread.demo1;  
  2.   
  3. public class MainTest {  
  4.     public static void main(String[] args) {  
  5.         ObjectService service=new ObjectService();  
  6.         ThreadA a=new ThreadA(service);  
  7.         a.setName("a");  
  8.         a.start();  
  9.         ThreadB b=new ThreadB(service);  
  10.         b.setName("b");  
  11.         b.start();  
  12.     }  
  13. }  


运行结果：

结论：

当一个线程访问ObjectService的一个synchronized (this)同步代码块时，其它线程对同一个ObjectService中其它的synchronized (this)同步代码块的访问将是堵塞，这说明synchronized (this)使用的对象监视器是一个。

 

验证synchronized (this)代码块是锁定当前对象

 

[java] view plain copy

  1. package com.zwz.thread.demo2;  
  2.   
  3. public class ObjectService {  
  4.     public void objectMethodA(){  
  5.         System.out.println("run----objectMethodA");  
  6.     }  
  7.     public void objectMethodB(){  
  8.         synchronized (this) {  
  9.             try {  
  10.                 for (int i = 1; i <= 10; i++) {  
  11.                     System.out.println("synchronized thread name:"+Thread.currentThread().getName()+"-->i="+i);  
  12.                     Thread.sleep(1000);  
  13.                 }  
  14.             } catch (InterruptedException e) {  
  15.                     e.printStackTrace();  
  16.             }  
  17.         }  
  18.     }  
  19. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo2;  
  2.   
  3. public class ThreadA extends Thread {  
  4.     private ObjectService objectService;  
  5.   
  6.     public ThreadA(ObjectService objectService) {  
  7.         super();  
  8.         this.objectService = objectService;  
  9.     }  
  10.     @Override  
  11.     public void run() {  
  12.         super.run();  
  13.         objectService.objectMethodA();  
  14.     }  
  15. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo2;  
  2.   
  3. public class ThreadB extends Thread {  
  4.     private ObjectService objectService;  
  5.   
  6.     public ThreadB(ObjectService objectService) {  
  7.         super();  
  8.         this.objectService = objectService;  
  9.     }  
  10.     @Override  
  11.     public void run() {  
  12.         super.run();  
  13.         objectService.objectMethodB();  
  14.     }  
  15. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo2;  
  2.   
  3. public class MainTest {  
  4.     public static void main(String[] args) throws InterruptedException {  
  5.         ObjectService service=new ObjectService();  
  6.         ThreadB b=new ThreadB(service);  
  7.         b.start();  
  8.         Thread.sleep(2000);  
  9.         ThreadA a=new ThreadA(service);  
  10.         a.start();  
  11.     }  
  12. }  


运行结果：

 

可以看到objectMethodA方法异步执行了，下面我们将objectMethodA()加上同步。

 

[java] view plain copy

  1. package com.zwz.thread.demo2;  
  2.   
  3. public class ObjectService {  
  4.     public synchronized void objectMethodA(){  
  5.         System.out.println("run----objectMethodA");  
  6.     }  
  7.     public void objectMethodB(){  
  8.         synchronized (this) {  
  9.             try {  
  10.                 for (int i = 1; i <= 10; i++) {  
  11.                     System.out.println("synchronized thread name:"+Thread.currentThread().getName()+"-->i="+i);  
  12.                     Thread.sleep(1000);  
  13.                 }  
  14.             } catch (InterruptedException e) {  
  15.                     e.printStackTrace();  
  16.             }  
  17.         }  
  18.     }  
  19. }  


运行结果：

 

结论：

上面三个小例子我们可以知道，多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized(this)同步代码块时，是同步的。

1、synchronized同步方法

①对其它的synchronized同步方法或synchronized(this)同步代码块调用是堵塞状态；

②同一时间只有一个线程执行synchronized同步方法中的代码。

2、synchronized(this)同步代码块

 

①对其它的synchronized同步方法或synchronized(this)同步代码块调用是堵塞状态；

②同一时间只有一个线程执行synchronized同步方法中的代码。

 

将任意对象作为对象监视器

 

[java] view plain copy

  1. package com.zwz.thread.demo3;  
  2.   
  3. public class ObjectService {  
  4.     private String uname;  
  5.     private String pwd;  
  6.     String lock=new String();  
  7.     public void setUserNamePassWord(String userName,String passWord){  
  8.         try {  
  9.             synchronized (lock) {  
  10.                 System.out.println("thread name="+Thread.currentThread().getName()  
  11.                         +" 进入代码快:"+System.currentTimeMillis());  
  12.                 uname=userName;  
  13.                 Thread.sleep(3000);  
  14.                 pwd=passWord;  
  15.                 System.out.println("thread name="+Thread.currentThread().getName()  
  16.                         +" 进入代码快:"+System.currentTimeMillis()+"入参uname:"+uname+"入参pwd:"+pwd);  
  17.             }  
  18.         } catch (InterruptedException e) {  
  19.             e.printStackTrace();  
  20.         }  
  21.     }  
  22. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo3;  
  2.   
  3. public class ThreadA extends Thread {  
  4.     private ObjectService objectService;  
  5.   
  6.     public ThreadA(ObjectService objectService) {  
  7.         super();  
  8.         this.objectService = objectService;  
  9.     }  
  10.     @Override  
  11.     public void run() {  
  12.         objectService.setUserNamePassWord("a", "aa");  
  13.     }  
  14. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo3;  
  2.   
  3. public class ThreadB extends Thread {  
  4.     private ObjectService objectService;  
  5.   
  6.     public ThreadB(ObjectService objectService) {  
  7.         super();  
  8.         this.objectService = objectService;  
  9.     }  
  10.     @Override  
  11.     public void run() {  
  12.         objectService.setUserNamePassWord("b", "bb");  
  13.     }  
  14. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo3;  
  2.   
  3. public class MainTest {  
  4.     public static void main(String[] args) {  
  5.         ObjectService service=new ObjectService();  
  6.         ThreadA a=new ThreadA(service);  
  7.         a.setName("A");  
  8.         a.start();  
  9.         ThreadB b=new ThreadB(service);  
  10.         b.setName("B");  
  11.         b.start();  
  12.     }  
  13. }  


运行结果：

 

下面我把String lock=new String();放在方法中会有啥结果了：

 

[java] view plain copy

  1. package com.zwz.thread.demo3;  
  2.   
  3. public class ObjectService {  
  4.     private String uname;  
  5.     private String pwd;  
  6.     public void setUserNamePassWord(String userName,String passWord){  
  7.         try {  
  8.             String lock=new String();  
  9.             synchronized (lock) {  
  10.                 System.out.println("thread name="+Thread.currentThread().getName()  
  11.                         +" 进入代码快:"+System.currentTimeMillis());  
  12.                 uname=userName;  
  13.                 Thread.sleep(3000);  
  14.                 pwd=passWord;  
  15.                 System.out.println("thread name="+Thread.currentThread().getName()  
  16.                         +" 进入代码快:"+System.currentTimeMillis()+"入参uname:"+uname+"入参pwd:"+pwd);  
  17.             }  
  18.         } catch (InterruptedException e) {  
  19.             e.printStackTrace();  
  20.         }  
  21.     }  
  22. }  


运行结果：

 

 

结论：

多个线程持有对象监视器作为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(任意自定义对象)同步代码快。

 

synchronized(任意自定义对象)与synchronized同步方法共用

 

[java] view plain copy

  1. package com.zwz.thread.demo4;  
  2.   
  3. public class ObjectService {  
  4.     private String lock=new String();  
  5.     public void methodA(){  
  6.         try {  
  7.             synchronized (lock) {  
  8.                 System.out.println("a begin");  
  9.                 Thread.sleep(3000);  
  10.                 System.out.println("a   end");  
  11.             }  
  12.         } catch (InterruptedException e) {  
  13.             e.printStackTrace();  
  14.         }  
  15.     }  
  16.     public synchronized void methodB(){  
  17.         System.out.println("b begin");  
  18.         System.out.println("b   end");  
  19.     }  
  20. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo4;  
  2.   
  3. public class ThreadA extends Thread {  
  4.     private ObjectService objectService;  
  5.   
  6.     public ThreadA(ObjectService objectService) {  
  7.         super();  
  8.         this.objectService = objectService;  
  9.     }  
  10.     @Override  
  11.     public void run() {  
  12.         objectService.methodA();  
  13.     }  
  14. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo4;  
  2.   
  3. public class ThreadB extends Thread {  
  4.     private ObjectService objectService;  
  5.   
  6.     public ThreadB(ObjectService objectService) {  
  7.         super();  
  8.         this.objectService = objectService;  
  9.     }  
  10.     @Override  
  11.     public void run() {  
  12.         objectService.methodB();  
  13.     }  
  14. }  

 

[java] view plain copy

  1. package com.zwz.thread.demo4;  
  2.   
  3. public class MainTest {  
  4.     public static void main(String[] args) {  
  5.         ObjectService service=new ObjectService();  
  6.         ThreadA a=new ThreadA(service);  
  7.         a.setName("A");  
  8.         a.start();  
  9.         ThreadB b=new ThreadB(service);  
  10.         b.setName("B");  
  11.         b.start();  
  12.     }  
  13.       
  14. }  


运行结果:

 

结论：

使用synchronized(任意自定义对象)进行同步操作，对象监视器必须是同一个对象。不过不是同一个，运行就是异步执行了。

 

静态同步synchronized方法与synchronized(*.class)代码块

 

静态同步synchronized方法

[java] view plain copy

  1. package com.zwz.thread.demo6;  
  2.   
  3. public class ObjectService {  
  4.     public synchronized static void methodA(){  
  5.         try {  
  6.             System.out.println("static methodA begin 线程名称:"+Thread.currentThread().getName()+" times:"+System.currentTimeMillis());  
  7.             Thread.sleep(3000);  
  8.             System.out.println("static methodA end   线程名称:"+Thread.currentThread().getName()+" times:"+System.currentTimeMillis());  
  9.         } catch (InterruptedException e) {  
  10.             e.printStackTrace();  
  11.         }  
  12.     }  
  13.       
  14.     public synchronized static void methodB(){  
  15.         System.out.println("static methodB begin 线程名称:"+Thread.currentThread().getName()+" times:"+System.currentTimeMillis());  
  16.         System.out.println("static methodB end   线程名称:"+Thread.currentThread().getName()+" times:"+System.currentTimeMillis());  
  17.     }  
  18. }  


[java] view plain copy

  1. package com.zwz.thread.demo6;  
  2.   
  3. public class ThreadA extends Thread {  
  4.   
  5.     @Override  
  6.     public void run() {  
  7.         ObjectService.methodA();  
  8.     }  
  9. }  


[java] view plain copy

  1. package com.zwz.thread.demo6;  
  2.   
  3. public class ThreadB extends Thread {  
  4.     @Override  
  5.     public void run() {  
  6.         ObjectService.methodB();  
  7.     }  
  8. }  


[java] view plain copy

  1. package com.zwz.thread.demo6;  
  2.   
  3. public class MainTest {  
  4.     public static void main(String[] args) {  
  5.         ThreadA a=new ThreadA();  
  6.         a.setName("A");  
  7.         a.start();  
  8.         ThreadB b=new ThreadB();  
  9.         b.setName("B");  
  10.         b.start();  
  11.     }  
  12. }  


运行结果：

结论：

synchronized应用在static方法上，那是对当前对应的*.Class进行持锁。

 

synchronized(*.class)代码块

[java] view plain copy

  1. package com.zwz.thread.demo7;  
  2.   
  3. public class ObjectService {  
  4.     public void methodA(){  
  5.         try {  
  6.             synchronized (ObjectService.class) {  
  7.                 System.out.println("methodA begin 线程名称:"+Thread.currentThread().getName()+" times:"+System.currentTimeMillis());  
  8.                 Thread.sleep(3000);  
  9.                 System.out.println("methodA end   线程名称:"+Thread.currentThread().getName()+" times:"+System.currentTimeMillis());  
  10.             }  
  11.         } catch (InterruptedException e) {  
  12.             e.printStackTrace();  
  13.         }  
  14.     }  
  15.       
  16.     public void methodB(){  
  17.         synchronized (ObjectService.class) {  
  18.             System.out.println("methodB begin 线程名称:"+Thread.currentThread().getName()+" times:"+System.currentTimeMillis());  
  19.             System.out.println("methodB end   线程名称:"+Thread.currentThread().getName()+" times:"+System.currentTimeMillis());  
  20.         }  
  21.     }  
  22. }  


[java] view plain copy

  1. package com.zwz.thread.demo7;  
  2.   
  3. public class ThreadA extends Thread {  
  4.     private ObjectService objectService;  
  5.   
  6.     public ThreadA(ObjectService objectService) {  
  7.         super();  
  8.         this.objectService = objectService;  
  9.     }  
  10.     @Override  
  11.     public void run() {  
  12.         objectService.methodA();  
  13.     }  
  14. }  


[java] view plain copy

  1. package com.zwz.thread.demo7;  
  2.   
  3. public class ThreadB extends Thread {  
  4.     private ObjectService objectService;  
  5.   
  6.     public ThreadB(ObjectService objectService) {  
  7.         super();  
  8.         this.objectService = objectService;  
  9.     }  
  10.     @Override  
  11.     public void run() {  
  12.         objectService.methodB();  
  13.     }  
  14. }  


[java] view plain copy

  1. package com.zwz.thread.demo7;  
  2.   
  3. public class MainTest {  
  4.     public static void main(String[] args) {  
  5.         ObjectService service=new ObjectService();  
  6.         ThreadA a=new ThreadA(service);  
  7.         a.setName("A");  
  8.         a.start();  
  9.         ThreadB b=new ThreadB(service);  
  10.         b.setName("B");  
  11.         b.start();  
  12.     }  
  13. }  


运行结果:

上面测试方法是共同对象，下面我们分别实例化一个对象：

[java] view plain copy

  1. package com.zwz.thread.demo7;  
  2.   
  3. public class MainTest {  
  4.     public static void main(String[] args) {  
  5.         ObjectService service1=new ObjectService();  
  6.         ObjectService service2=new ObjectService();  
  7.         ThreadA a=new ThreadA(service1);  
  8.         a.setName("A");  
  9.         a.start();  
  10.         ThreadB b=new ThreadB(service2);  
  11.         b.setName("B");  
  12.         b.start();  
  13.     }  
  14. }  


运行结果：

结论：

同步synchronized(*.class)代码块的作用其实和synchronized static方法作用一样。Class锁对类的所有对象实例起作用。

转载于:https://my.oschina.net/lsl1991/blog/1581665

weixin_33895657
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实例解析Java中的synchronized关键字与线程安全问题
09-02
- 形式：`synchronized (object) { // 代码 }` - 锁定范围：指定对象的监视器，只有拥有该对象锁的线程才能进入代码块。 - 作用：确保在同一时间只有一个线程能够执行该代码块，提高并发性。 2. **synchronized...
举例讲解Java中synchronized关键字的用法
09-02
当`synchronized`关键字修饰一个非静态方法时，该方法的锁作用于`this`对象，即当前实例对象。这意味着，如果两个线程分别通过不同的实例对象调用同一个`synchronized`方法，它们可以并行执行，因为它们持有不同的...
synchronized(this)与synchronized(class)
weixin_34128501的博客
12-18 212
synchronized(class)很特别，它会让另一个线程在任何需要获取class做为monitor的地方等待．class与this做为不同的监视器可以同时使用，不存在一个线程获取了class，另一个线程就不能获取该class的一切实例．   根据下面的代码自行修改,分别验证下面的几种情况： synchronized(class)synchronized(this)－＞线程各自获取mon...
【Synchronized】synchronized(this)、synchronized(class)与synchronized(Object)的区别
后端研发工程师Marion的博客
03-21 409
一、参考资料 synchronized(this)、synchronized(class)与synchronized(Object)的区别
synchronized(this)与synchronized(class)区别
Ethan_Fu的专栏
03-12 1266
synchronized(class)很特别，它会让另一个线程在任何需要获取class做为monitor的地方等待．class与this做为不同的监视器可以同时使用，不存在一个线程获取了class，另一个线程就不能获取该class的一切实例．   根据下面的代码自行修改,分别验证下面的几种情况： synchronized(class) synchronized(this) －＞线程各自获
Java Synchronized锁失败案例及解决方案
08-19
synchronized (object) { Thread thread = Thread.currentThread(); System.out.println(thread.getName() + "--@:---" + System.identityHashCode(num)); num++; System.out.println(thread.getName() + "----...
synchronized并发讲解源码.zip
03-16
除了锁住对象或类，`synchronized`还可以与`wait()`、`notify()`和`notifyAll()`方法结合使用，实现复杂的线程通信和同步。这些方法都是在`Object`类中定义的，只有在持有对象锁的情况下才能调用，否则会抛出`...
java多线程编程之使用Synchronized块同步方法
09-04
在内部类（InnerClass）中，如果需要与外部类的非静态方法同步，可以使用`OuterClass.this`作为同步锁，例如： ```java public class SyncBlock { class InnerClass { public void innerMethod() { synchronized...
synchronized（this）和synchronized（.class）的理解
somnous·G的博客
05-06 9481
synchronized（this）和synchronized（.class）的理解synchronized（this）验证：同一对象的Thread（苇名一心）：不同对象的Thread（苇名一心和苇名弦一郎）synchronized（ .class）验证： 对象锁（this）和类锁(class)产生的效果不同，对象锁只对当前对象加锁，而类锁是对指定类加锁。 举个例子： class person i...
synchronized(this) 与synchronized(class) 之间的区别
qq_21479345的博客
09-06 632
一、概念 synchronized 是 Java 中的关键字，是利用锁的机制来实现同步的。 锁机制有如下两种特性： 互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程中的协调机制，这样在同一时间只有一个线程对需同步的代码块(复合操作)进行访问。互斥性我们也往往称为操作的原子性。 可见性：必须确保在锁被释放之前，对共享变量所做的修改，对于随后获得该锁...
同步关键字synchronized对this、class、object、方法的区别
weixin_34232744的博客
03-24 154
synchronized的语义 实验 分析 在看源代码时遇到多线程需要同步的时候，总是会看见几种写法，修饰方法、修饰静态方法、synchronized(Xxx.class)、synchronized(this)、synchronized(obj)，之前一直没深究几种方式的区别，现在想来真是惊出一身冷汗，居然这个问题都没有仔细想清楚。 synchronized的语义 每个对象都有一个监视...
synchronized(this)、synchronized(.class)、锁静态方法、方法区别？
ke1ying的博客
08-23 793
synchronized(this)、synchronized(.class)、锁静态方法、锁方法区别
synchronized(this)、synchronized(*.class)与synchronized(任意对象)这几种类型同步方法
qq_27600345的博客
05-22 1488
复制自：https://blog.csdn.net/luckey_zh/article/details/53815694在多线程开发中，我们经常看到synchronized(this)、synchronized(*.class)与synchronized(任意对象)这几种类型同步方法。但是是否知道这几种写法有什么区别了？下面根据代码来分析：1、当一个线程访问ObjectService的一个sync...
java 中 synchronized (class) 是什么意思?
studyvcmfc的专栏
07-09 1940
XXX.class本身是XXX类的一个静态属性，也是一个对象。 锁XXX.class的意思就是对整个类加锁，也就是说无论创建了多少个XXX类的对象，这些对象都共享一个相同的锁标记。
Java synchronized(this)与synchronized(object)的区别
最新发布
11-20
synchronized(this)和synchronized(object)都是用于同步代码块的，但是它们的作用范围是不同的。 synchronized(this)用于同步当前对象的代码块，即在当前对象上加锁。这意味着在同一时刻只有一个线程可以执行该代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值