Java中synchronized：特性、使用、锁机制与策略简析

小灰灰 2023-10-16 11:39 9阅读 0赞

#### 目录 ####

*   *  synchronized的特性
     *   *  互斥性
         *  可见性
         *  可重入性
     *  synchronized的使用方法
     *  synchronized的锁机制
     *  常见锁策略
     *   *  乐观锁与悲观锁
         *  重量级锁与轻量级锁
         *  公平锁与非公平锁
         *  可重入锁与不可重入锁
         *  自旋锁
         *  读写锁

### synchronized的特性 ###

#### 互斥性 ####

synchronized确保同一时间只有一个线程可以进入同步块或同步方法，避免了多线程并发访问共享资源的冲突问题。  
synchronized 会起到互斥效果，某个线程执行到某个对象的 synchronized 中时， 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待。  
下面我们来看一个例子，两个线程获取同一个锁，锁被占用后，剩下的那个线程就会进行阻塞等待。

public class test2 {
        
        public static void main(String[] args) {
        
            Object object = new Object();
            Thread t1 =  new Thread(()->{
        
            //进入 synchronized 修饰的代码块, 相当于 加锁
              synchronized (object) {
        
                  for (int i = 0; i < 5; i++) {
        
                      System.out.println("线程t1获取锁");
                      try {
        
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
        
                          throw new RuntimeException(e);
                      }
                  }
              }
            //退出 synchronized 修饰的代码块, 相当于 解锁  
            });
            Thread t2 = new Thread(()->{
        
                synchronized (object) {
        
                    for (int i = 0; i < 5; i++) {
        
                        System.out.println("线程特t2获取锁");
                        try {
        
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                }
            });
            t1.start();
            t2.start();
        }
    }

![在这里插入图片描述][e663cf523da54f2aa891a22813f2dee2.png]  
由结果我们可以知道，线程一释放锁后，由操作系统唤醒线程二才能获取到锁。

> synchronized的底层是使用操作系统的mutex lock实现的。

#### 可见性 ####

> 内存可见性是指当一个线程修改了共享变量的值后，其他线程能够立即看到修改的值。在多线程环境中，由于多个线程同时访问共享变量，每个线程都有自己的工作内存，而工作内存中保存了主内存中的部分数据副本。因此，当一个线程修改了共享变量的值，但这个修改尚未被刷新到主内存时，其他线程可能无法立即看到这个修改，而继续使用自己工作内存中的旧值，造成了内存不可见性。

synchronized 既能保证原子性，也能保证内存可见性，一个线程对共享变量的修改对于其他线程是可见的。

class Counter {
        
        public static int flag = 0;
    }
    
    public class test3 {
        
        public static void main(String[] args) {
        
            Object object = new Object();
            Thread t1 = new Thread(() -> {
        
                while (true) {
        
                    synchronized (object) {
        
                        if (Counter.flag != 0) {
        
                            break;
                        }
                    }
                }
                System.out.println("线程一知道了共享变量改为" + Counter.flag);
            });
            Thread t2 = new Thread(() -> {
        
                Scanner scanner = new Scanner(System.in);
                System.out.println("输入一个整数:");
                Counter.flag = scanner.nextInt();
            });
            t1.start();
            t2.start();
        }
    }

![在这里插入图片描述][6474f88323c44ac78de3dccba3df3bee.png]  
如果线程一不加synchronized，那么共享变量的改变它就感知不到，以至于程序一直在运行中。  
![在这里插入图片描述][29e1c931202143a185964e8d46740467.png]

#### 可重入性 ####

synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。  
可以理解为一个线程没有释放锁，然后又尝试再次加锁。  
按照之前对锁的理解就是，锁没有释放，进行再次加锁就会进行阻塞，直到第一次的锁被释放，才能获取到第二个锁，但释放第一个锁也由该线程来进行，结果现在这个线程啥都干不了，也就只能形成死锁了。  
这样的锁称其为不可重入锁。

我们的synchronized是可重入锁。  
在重入锁的内部有两个信息，分别为“程序计数器”和“线程持有者”

*  如果某个线程加锁的时候，发现锁已经被人占用，但是恰好占用的正是自己， 那么仍然可以继续获取到锁，并让计数器自增。
 *  解锁的时候计数器递减为 0 的时候，才真正释放锁。

### synchronized的使用方法 ###

1.  直接修饰普通方法: 锁的 SynchronizedDemo 对象

public synchronized void methond() {
        
    }

1.  修饰静态方法: 锁的 SynchronizedDemo 类的对象

public synchronized static void method() {
        
    }

1.  修饰代码块: 明确指定锁哪个对象

*  锁当前对象

public void method() {
        
    synchronized (this) {
        
    }
    }

*  锁类对象

public void method() {
        
    synchronized (SynchronizedDemo.class) {
        
    }
    }

### synchronized的锁机制 ###

1.  对象锁：可以将synchronized关键字直接应用于实例方法或实例代码块上。当一个线程进入被synchronized修饰的实例方法或实例代码块时，它会自动获取该对象的内置锁。只有当线程释放锁之后，其他线程才能进入同步块。
2.  类锁：可以将synchronized关键字应用于静态方法或类代码块上。当一个线程进入被synchronized修饰的静态方法或类代码块时，它会自动获取该类的Class对象的内置锁。类锁是属于整个类的，对于同一个类的不同实例，他们共享同一个类锁。
3.  锁对象：可以使用synchronized关键字加锁指定的对象。通过指定一个对象作为锁，多个线程可以根据这个对象来实现同步。当一个线程进入synchronized代码块时，它会尝试获取指定对象的内置锁，只有当线程释放锁之后，其他线程才能获得锁并执行同步代码。

### 常见锁策略 ###

#### 乐观锁与悲观锁 ####

悲观锁是在数据被使用前加锁，防止数据被其他线程修改。  
乐观锁则是在更新数据时检查数据是否被其他线程修改过，如果没有则更新成功，否则返回失败。  
Synchronized 初始使用乐观锁策略，当发现锁竞争比较频繁的时候, 就会自动切换成悲观锁策略。

#### 重量级锁与轻量级锁 ####

轻量级锁是一种优化的锁，它在CAS操作时使用CPU的自旋机制，如果自旋成功则获取到锁，否则进入睡眠状态。  
重量级锁是一种传统的锁，它依赖于操作系统的MutexLock(互斥锁)来实现，当有多个线程竞争同一个锁时，会阻塞其他线程等待释放。

#### 公平锁与非公平锁 ####

假设有A，B，C三个线程**依次**进行同一把锁的获取，线程A获取成功了，线程B与C获取失败。  
等待线程A释放锁后，线程B与C，如何获取锁![在这里插入图片描述][66958e886e3447de9e7c44cc1ddfa0c1.png]  
公平锁策略： 遵守 “先来后到”。B 比 C 先来的。当 A 释放锁的之后，B 就能先于 C 获取到锁。  
非公平锁策略：不遵守 “先来后到”。B 和 C 都有可能获取到锁。  
**synchronized 是非公平锁**

#### 可重入锁与不可重入锁 ####

可重入锁的意思就是允许同一个线程多次获取同一把锁。  
Java里只要以Reentrant开头命名的锁都是可重入锁，而且JDK提供的所有现成的Lock实现类，包括synchronized关键字锁都是可重入的。  
可以理解为一个线程没有释放锁，然后又尝试再次加锁。  
按照之前对锁的理解就是，锁没有释放，进行再次加锁就会进行阻塞，直到第一次的锁被释放，才能获取到第二个锁，但释放第一个锁也由该线程来进行，结果现在这个线程啥都干不了，也就只能形成死锁了。  
这样的锁称其为不可重入锁。

**synchronized 是可重入锁**

#### 自旋锁 ####

为防止线程在抢锁失败后进入阻塞状态，经过很久才能再次被调度的情况。

while (!locked.compareAndSet(false, true)) {
        
                // 不断循环直到获取到锁
            }

如果获取锁失败，立即再尝试获取锁， 无限循环，直到获取到锁为止。 第一次获取锁失败, 第二次的尝试会在极短的时间内到来。  
缺点：如果锁被其他线程持有的时间比较久， 那么就会持续的消耗 CPU 资源。  
**synchronized 中的轻量级锁策略大概率就是通过自旋锁的方式实现的**

#### 读写锁 ####

一个线程对于数据的访问, 主要存在两种操作: 读数据 和 写数据.

*  两个线程都只是读一个数据, 此时并没有线程安全问题. 直接并发的读取即可.
 *  两个线程都要写一个数据, 有线程安全问题.
 *  一个线程读另外一个线程写, 也有线程安全问题.
    
    读写锁就是把读操作和写操作区分对待。 Java 标准库提供了ReentrantReadWriteLock 类，实现了读写锁。
 *  ReentrantReadWriteLock.ReadLock 类表示一个读锁。这个对象提供了 lock / unlock 方法进行加锁解锁。
 *  ReentrantReadWriteLock.WriteLock 类表示一个写锁。 这个对象也提供了 lock / unlock 方法进行加锁解锁

> 读加锁和读加锁之间, 不互斥.  
> 写加锁和写加锁之间, 互斥.  
> 读加锁和写加锁之间, 互斥

**Synchronized 不是读写锁**

[想了解更多也可以看我的笔记专栏哈哈][Link 1]![在这里插入图片描述][ba30dee1a51142ddb10d33d518073237.png]

[e663cf523da54f2aa891a22813f2dee2.png]: https://img-blog.csdnimg.cn/e663cf523da54f2aa891a22813f2dee2.png
[6474f88323c44ac78de3dccba3df3bee.png]: https://img-blog.csdnimg.cn/6474f88323c44ac78de3dccba3df3bee.png
[29e1c931202143a185964e8d46740467.png]: https://img-blog.csdnimg.cn/29e1c931202143a185964e8d46740467.png
[66958e886e3447de9e7c44cc1ddfa0c1.png]: https://img-blog.csdnimg.cn/66958e886e3447de9e7c44cc1ddfa0c1.png
[Link 1]: http://t.csdn.cn/A43iA
[ba30dee1a51142ddb10d33d518073237.png]: https://img-blog.csdnimg.cn/ba30dee1a51142ddb10d33d518073237.png