Java的Synchronized关键字学习指南(全面 & 详细)

前言

在Java中，有一个常被忽略 但 非常重要的关键字Synchronized今天，我将详细讲解 Java关键字Synchronized的所有知识，希望你们会喜欢

目录

1. 定义

Java中的1个关键字

2. 作用

保证同一时刻最多只有1个线程执行 被Synchronized修饰的方法 / 代码

其他线程 必须等待当前线程执行完该方法 / 代码块后才能执行该方法 / 代码块

3. 应用场景

保证线程安全，解决多线程中的并发同步问题（实现的是阻塞型并发），具体场景如下：

修饰 实例方法 / 代码块时，（同步）保护的是同一个对象方法的调用 & 当前实例对象修饰 静态方法 / 代码块时，（同步）保护的是 静态方法的调用 & class 类对象

4. 原理

依赖 JVM 实现同步底层通过一个监视器对象（monitor）完成， wait（）、notify（） 等方法也依赖于 monitor 对象

监视器锁（monitor）的本质 依赖于 底层操作系统的互斥锁（Mutex Lock）实现

5. 具体使用

Synchronized 用于 修饰 代码块、类的实例方法 & 静态方法

5.1 使用规则

5.2 锁的类型 & 等级 由于Synchronized 会修饰 代码块、类的实例方法 & 静态方法，故分为不同锁的类型具体如下

之间的区别

5.3 使用方式

1. /**
2. * 对象锁
3. */
4. public class Test{
5. // 对象锁：形式1(方法锁)
6. public synchronized void Method1(){
7. System.out.println("我是对象锁也是方法锁");
8. try{
9. Thread.sleep(500);
10. } catch (InterruptedException e){
11. e.printStackTrace();
12. }
13.  
14. }
15.  
16. // 对象锁：形式2（代码块形式）
17. public void Method2(){
18. synchronized (this){
19. System.out.println("我是对象锁");
20. try{
21. Thread.sleep(500);
22. } catch (InterruptedException e){
23. e.printStackTrace();
24. }
25. }
26.  
27. }
28. ｝
29.  
30. /**
31. * 方法锁（即对象锁中的形式1）
32. */
33. public synchronized void Method1(){
34. System.out.println("我是对象锁也是方法锁");
35. try{
36. Thread.sleep(500);
37. } catch (InterruptedException e){
38. e.printStackTrace();
39. }
40.  
41. }
42.  
43. /**
44. * 类锁
45. */
46. public class Test{
47. 　　 // 类锁：形式1 ：锁静态方法
48. public static synchronized void Method1(){
49. System.out.println("我是类锁一号");
50. try{
51. Thread.sleep(500);
52. } catch (InterruptedException e){
53. e.printStackTrace();
54. }
55.  
56. }
57.  
58. // 类锁：形式2 ：锁静态代码块
59. public void Method2(){
60. synchronized (Test.class){
61. System.out.println("我是类锁二号");
62. try{
63. Thread.sleep(500);
64. } catch (InterruptedException e){
65. e.printStackTrace();
66. }
67.  
68. }
69.  
70. }
71. ｝

5.4 特别注意

Synchronized修饰方法时存在缺陷：若修饰1个大的方法，将会大大影响效率

示例

若使用Synchronized关键字修饰 线程类的run()，由于run()在线程的整个生命期内一直在运行，因此将导致它对本类任何Synchronized方法的调用都永远不会成功

解决方案

使用 Synchronized关键字声明代码块

该解决方案灵活性高：可针对任意代码块 & 任意指定上锁的对象

1. 代码如下
2. synchronized(syncObject) {
3. // 访问或修改被锁保护的共享状态
4. // 上述方法 必须 获得对象 syncObject（类实例或类）的锁
5. }

6. 特点

注：原子性、可见性、有序性的定义

7. 其他控制并发 / 线程同步方式

7.1 Lock、ReentrantLock 简介

区别

7.2 CAS

7.2.1 定义

Compare And Swap，即 比较 并 交换，是一种解决并发操作的乐观锁

synchronized锁住的代码块：同一时刻只能由一个线程访问，属于悲观锁

7.2.2 原理

1. // CAS的操作参数
2. 内存位置（A）
3. 预期原值（B）
4. 预期新值（C）
5.  
6. // 使用CAS解决并发的原理：
7. // 1. 首先比较A、B，若相等，则更新A中的值为C、返回True；若不相等，则返回false；
8. // 2. 通过死循环，以不断尝试尝试更新的方式实现并发
9.  
10. // 伪代码如下
11. public boolean compareAndSwap(long memoryA, int oldB, int newC){
12. if(memoryA.get() == oldB){
13. memoryA.set(newC);
14. return true;
15. }
16. return false;
17. }

7.2.3 优点

资源耗费少：相对于synchronized，省去了挂起线程、恢复线程的开销

但，若迟迟得不到更新，死循环对CPU资源也是一种浪费

7.2.4 具体实现方式 使用CAS有个“先检查后执行”的操作而这种操作在Java中是典型的不安全的操作，所以 CAS在实际中是由C++通过调用CPU指令实现的具体过程

1. // 1. CAS在Java中的体现为Unsafe类
2. // 2. Unsafe类会通过C++直接获取到属性的内存地址
3. // 3. 接下来CAS由C++的Atomic::cmpxchg系列方法实现

7.2.5 典型应用：AtomicInteger

对 i++ 与 i–，通过compareAndSet & 一个死循环实现

而compareAndSet函数内部 = 通过jni操作CAS指令。直到CAS操作成功跳出循环

1. private volatile int value;
2. /**
3. * Gets the current value.
4. *
5. * @return the current value
6. */
7. public final int get() {
8. return value;
9. }
10. /**
11. * Atomically increments by one the current value.
12. *
13. * @return the previous value
14. */
15. public final int getAndIncrement() {
16. for (;;) {
17. int current = get();
18. int next = current + 1;
19. if (compareAndSet(current, next))
20. return current;
21. }
22. }
23.  
24. /**
25. * Atomically decrements by one the current value.
26. *
27. * @return the previous value
28. */
29. public final int getAndDecrement() {
30. for (;;) {
31. int current = get();
32. int next = current - 1;
33. if (compareAndSet(current, next))
34. return current;
35. }
36. }

8. 总结

本文主要对Java中常被忽略 但 非常重要的关键字Synchronized进行讲解

到此这篇关于Java的Synchronized关键字学习指南的文章就介绍到这了,更多相关Java的Synchronized关键字内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/carson_ho/article/details/82992269