Synchronized 加锁 This 和Class 的区别！

也想出现在这里？点击联系我~

synchronized 是 Java 语言中处理并发问题的一种常用手段，它也被我们亲切的称之为“Java 内置锁”，由此可见其地位之高。然而 synchronized 却有着多种用法，当它修饰不同对象时，其意义也是不同的，下面我们一起来看。

synchronized 用法

synchronized 可以用来修饰普通方法、静态方法和代码块。

① 修饰普通方法

1. /**
2. *synchronized修饰普通方法
3. */
4. publicsynchronizedvoidmethod(){
5. //…….
6. }

当 synchronized 修饰普通方法时，被修饰的方法被称为同步方法，其作用范围是整个方法，作用的对象是调用这个方法的对象。

② 修饰静态方法

1. /**
2. *synchronized修饰静态方法
3. */
4. publicstaticsynchronizedvoidstaticMethod(){
5. //…….
6. }

当 synchronized 修饰静态的方法时，其作用的范围是整个方法，作用对象是调用这个类的所有对象。

③ 修饰代码块

为了减少锁的粒度，我们可以选择在一个方法中的某个部分使用 synchronized 来修饰(一段代码块)，从而实现对一个方法中的部分代码进行加锁，实现代码如下：

1. publicvoidclassMethod()throwsInterruptedException{
2. //前置代码…
4. //加锁代码
5. synchronized(SynchronizedExample.class){
6. //……
7. }
9. //后置代码…
10. }

以上代码在执行时，被修饰的代码块称为同步语句块，其作用范围是大括号“{}”括起来的代码块，作用的对象是调用这个代码块的对象。

但以上代码，除了可以加锁 class 之外，还可以加锁 this，具体示例如下：

1. publicvoidclassMethod()throwsInterruptedException{
2. //前置处理代码…
3. synchronized(this){
4. //……
5. }
6. //后置处理代码…
7. }

那问题来了，使用 synchronized 加锁 this 和 class 的区别是什么?不都是加锁同一个类吗?

答案还真不是，加锁 this 和 class 区别还是很大的。下面我们通过以下 4 个示例，来看二者之间的区别。

1.加锁 class 共享一个类实例

首先，我们创建 5 个线程，调用同一个对象下 synchronized 加锁的 class 代码，具体示例如下：

1. importjava.util.Date;
2. importjava.util.concurrent.TimeUnit;
4. publicclassSynchronizedExample{
6. publicstaticvoidmain(String[]args){
7. //创建当前类实例
8. finalSynchronizedExampleexample=newSynchronizedExample();
9. //创建5个线程执行任务
10. for(inti=0;i<5;i++){
11. newThread(newRunnable(){
12. @Override
13. publicvoidrun(){
14. try{
15. //调用synchronized修饰的class方法
16. example.classMethod();
17. }catch(InterruptedExceptione){
18. e.printStackTrace();
19. }
20. }
21. }).start();
22. }
23. }
25. /**
26. *synchronized修饰的class方法
27. *@throwsInterruptedException
28. */
29. publicvoidclassMethod()throwsInterruptedException{
30. synchronized(SynchronizedExample.class){
31. System.out.println(String.format("当前执行线程:%s,执行时间:%s",
32. Thread.currentThread().getName(),newDate()));
33. TimeUnit.SECONDS.sleep(1);
34. }
35. }
36. }

以上程序的执行结果如下：

从上述结果可以看出，这 5 个线程共享的是同一把锁。

2.加锁 class 创建多个实例

接下来，我们创建 5 个线程，调用不同对象下 synchronized 加锁的 class 代码，具体示例如下：

1. importjava.util.Date;
2. importjava.util.concurrent.TimeUnit;
4. publicclassSynchronizedExample{
6. publicstaticvoidmain(String[]args){
7. //创建5个线程执行任务
8. for(inti=0;i<5;i++){
9. newThread(newRunnable(){
10. @Override
11. publicvoidrun(){
12. try{
13. //创建类实例
14. SynchronizedExampleexample=newSynchronizedExample();
15. //调用synchronized修饰的class方法
16. example.classMethod();
17. }catch(InterruptedExceptione){
18. e.printStackTrace();
19. }
20. }
21. }).start();
22. }
23. }
25. /**
26. *synchronized修饰的class方法
27. *@throwsInterruptedException
28. */
29. publicvoidclassMethod()throwsInterruptedException{
30. synchronized(SynchronizedExample.class){
31. System.out.println(String.format("当前执行线程:%s,执行时间:%s",
32. Thread.currentThread().getName(),newDate()));
33. TimeUnit.SECONDS.sleep(1);
34. }
35. }
36. }

以上程序的执行结果如下：

从上述结果可以看出，虽然是不同的对象，但它们使用的仍然是同一把锁。

3.加锁 this 共享一个类实例

接下来，我们创建 5 个线程，调用 synchronized 加锁 this 的示例。首先我们这 5 个线程调用同一个对象的加锁方法，示例代码如下：

1. importjava.util.Date;
2. importjava.util.concurrent.TimeUnit;
4. publicclassSynchronizedExample{
6. publicstaticvoidmain(String[]args){
7. //创建当前类实例
8. finalSynchronizedExampleexample=newSynchronizedExample();
9. //创建5个线程执行任务
10. for(inti=0;i<5;i++){
11. newThread(newRunnable(){
12. @Override
13. publicvoidrun(){
14. try{
15. //调用synchronized修饰的this方法
16. example.thisMethod();
17. }catch(InterruptedExceptione){
18. e.printStackTrace();
19. }
20. }
21. }).start();
22. }
23. }
25. /**
26. *synchronized修饰的this方法
27. *@throwsInterruptedException
28. */
29. publicvoidthisMethod()throwsInterruptedException{
30. synchronized(this){
31. System.out.println(String.format("当前执行线程:%s,执行时间:%s",
32. Thread.currentThread().getName(),newDate()));
33. TimeUnit.SECONDS.sleep(1);
34. }
35. }
36. }

以上程序的执行结果如下：

从上述结果可以看出，以上线程使用的都是同一把锁。

4.加锁 this 创建多个类实例

最后一个示例最为特殊，我们使用 synchronized 加锁 this，让这 5 个线程调用各自创建对象的方法，具体示例如下：

1. importjava.util.Date;
2. importjava.util.concurrent.TimeUnit;
4. publicclassSynchronizedExample{
6. publicstaticvoidmain(String[]args){
7. //创建5个线程执行任务
8. for(inti=0;i<5;i++){
9. newThread(newRunnable(){
10. @Override
11. publicvoidrun(){
12. try{
13. //创建（多个）类实例
14. SynchronizedExampleexample=newSynchronizedExample();
15. //调用synchronized修饰的this方法
16. example.thisMethod();
17. }catch(InterruptedExceptione){
18. e.printStackTrace();
19. }
20. }
21. }).start();
22. }
23. }
25. /**
26. *synchronized修饰的this方法
27. *@throwsInterruptedException
28. */
29. publicvoidthisMethod()throwsInterruptedException{
30. synchronized(this){
31. System.out.println(String.format("当前执行线程:%s,执行时间:%s",
32. Thread.currentThread().getName(),newDate()));
33. TimeUnit.SECONDS.sleep(1);
34. }
35. }
36. }

以上程序的执行结果如下：

从上述结果可以看出，当使用 synchronized 加锁 this 时，如果线程调用的不是同一个对象，那么这些线程之间使用的锁都是自己独立的锁，这个结果就和 synchronized 加锁 class 的结果完全不同了。

总结

通过以上 4 个示例我们可以得出结论，当使用 synchronized 加锁 class 时，无论共享一个对象还是创建多个对象，它们用的都是同一把锁，而使用 synchronized 加锁 this 时，只有同一个对象会使用同一把锁，不同对象之间的锁是不同的。

原文链接：https://mp.weixin.qq.com/s/7DTk5CV5FSOsa5fSN_V26w