Java同步锁怎么用？手把手教你synchronized的4种正确姿势

小伙伴们有没有觉得学习文章很有意思？有意思就对了！今天就给大家带来《Java同步锁怎么用？手把手教你synchronized的4种姿势》，以下内容将会涉及到，若是在学习中对其中部分知识点有疑问，或许看了本文就能帮到你！

synchronized关键字在Java中用于实现线程同步，确保多线程并发访问共享资源时的互斥执行。其主要使用方式包括：1. 同步代码块，通过指定对象作为锁；2. 同步方法，锁为当前对象（this）或类对象（Class）；3. 静态同步方法，等价于使用类对象作为锁；4. 同步静态变量，通常使用静态对象作为锁。此外，synchronized依赖JVM的monitor机制，通过monitorenter和monitorexit指令实现锁的获取与释放，并在JDK 1.6后通过锁优化提升了性能。相比ReentrantLock，synchronized是隐式锁，自动释放，而ReentrantLock需要手动释放且提供更多功能，但更易出错。避免死锁的方法包括统一锁顺序、限制锁持有时间、使用定时锁及工具检测。

synchronized关键字在Java中用于实现线程同步，确保多个线程在并发访问共享资源时，只有一个线程可以执行特定代码块或方法，从而避免数据竞争和不一致性。它本质上提供了一种互斥锁机制。

解决方案

synchronized关键字主要有四种使用方式：

1. 同步代码块（Synchronized Block）：

   通过synchronized(object)来指定一个对象作为锁。任何时刻，只能有一个线程获得该对象的锁，其他线程必须等待。

   public class Counter {
       private int count = 0;
       private Object lock = new Object(); // 锁对象
   
       public void increment() {
           synchronized (lock) {
               count++;
           }
       }
   
       public int getCount() {
           return count;
       }
   }

   这里，lock对象充当了锁，只有获得lock锁的线程才能执行count++操作。 选择哪个对象作为锁至关重要。 如果多个线程访问不同的Counter实例，那么每个实例都有自己的lock对象，同步就无效了。

2. 同步方法（Synchronized Method）：

   将整个方法声明为synchronized。 对于实例方法，锁是当前对象（this）；对于静态方法，锁是当前类（Class对象）。

   public class Counter {
       private int count = 0;
   
       public synchronized void increment() {
           count++;
       }
   
       public int getCount() {
           return count;
       }
   }

   等价于：

   public class Counter {
       private int count = 0;
   
       public void increment() {
           synchronized (this) {
               count++;
           }
       }
   
       public int getCount() {
           return count;
       }
   }

   静态同步方法：

   public class Counter {
       private static int count = 0;
   
       public static synchronized void increment() {
           count++;
       }
   
       public static int getCount() {
           return count;
       }
   }

   等价于：

   public class Counter {
       private static int count = 0;
   
       public static void increment() {
           synchronized (Counter.class) {
               count++;
           }
       }
   
       public static int getCount() {
           return count;
       }
   }

3. 同步静态变量（不常用）：

   虽然不常见，但也可以通过同步静态变量来实现同步。 这本质上和同步代码块使用Class对象作为锁是一样的。

   public class Counter {
       private static int count = 0;
       private static Object staticLock = new Object();
   
       public static void increment() {
           synchronized (staticLock) {
               count++;
           }
       }
   
       public static int getCount() {
           return count;
       }
   }

4. 隐式锁（Intrinsic Lock or Monitor Lock）：

   当线程进入synchronized块或方法时，它会自动获得与对象关联的隐式锁。 当线程退出synchronized块或方法时，锁会被自动释放。 这种锁是可重入的，意味着同一个线程可以多次获得同一个锁而不会阻塞。

Synchronized 和 ReentrantLock 的区别是什么？

• synchronized 是 Java 关键字，属于 JVM 层面，而 ReentrantLock 是一个类，属于 API 层面。
• synchronized 会自动释放锁，而 ReentrantLock 需要手动释放锁（lock.unlock()），如果忘记释放，可能会导致死锁。
• ReentrantLock 提供了更多的功能，例如可中断的锁、公平锁等，而 synchronized 相对简单。
• 性能方面，在 JDK 1.6 之后，synchronized 进行了大量的优化，在低并发情况下，性能可能优于 ReentrantLock，但在高并发情况下，ReentrantLock 通常性能更好。 理论上，ReentrantLock更灵活，但用不好也更容易出错。

如何避免死锁？

死锁是指两个或多个线程互相持有对方需要的资源，导致所有线程都无法继续执行的情况。 避免死锁的一些常见策略：

• 避免循环等待： 确保线程获取锁的顺序是一致的，避免形成循环依赖。
• 限制锁的持有时间： 尽量缩短持有锁的时间，减少其他线程等待锁的机会。
• 使用定时锁： 使用 ReentrantLock 的 tryLock(long timeout, TimeUnit unit) 方法，设置超时时间，避免无限等待。
• 死锁检测： 一些工具可以检测死锁，例如 JConsole 和 VisualVM。

举个例子，假设有两个线程 A 和 B，它们都需要获取锁 lock1 和 lock2。如果线程 A 先获取了 lock1，然后尝试获取 lock2，而线程 B 先获取了 lock2，然后尝试获取 lock1，那么就可能发生死锁。

Object lock1 = new Object();
Object lock2 = new Object();

// 线程 A
new Thread(() -> {
    synchronized (lock1) {
        System.out.println("线程 A 获取了 lock1");
        try { Thread.sleep(100); } catch (InterruptedException e) {}
        synchronized (lock2) {
            System.out.println("线程 A 获取了 lock2");
        }
    }
}).start();

// 线程 B
new Thread(() -> {
    synchronized (lock2) {
        System.out.println("线程 B 获取了 lock2");
        try { Thread.sleep(100); } catch (InterruptedException e) {}
        synchronized (lock1) {
            System.out.println("线程 B 获取了 lock1");
        }
    }
}).start();

在这个例子中，如果线程 A 获取了 lock1，线程 B 获取了 lock2，然后它们互相等待对方释放锁，就会发生死锁。 避免这种情况，可以确保两个线程以相同的顺序获取锁，例如都先获取 lock1，再获取 lock2。

Synchronized的底层实现原理是什么？

synchronized 的实现依赖于 JVM 的 monitor（监视器锁）机制。 每个 Java 对象都关联一个 monitor，当线程执行到 synchronized 块或方法时，会尝试获取 monitor 的所有权。 如果 monitor 没有被其他线程持有，则该线程成功获取 monitor，并将 monitor 的计数器加 1。 如果 monitor 已经被其他线程持有，则该线程会被阻塞，直到 monitor 的计数器变为 0，即持有 monitor 的线程释放了锁。

在 JVM 层面，synchronized 是通过 monitorenter 和 monitorexit 指令来实现的。 monitorenter 指令用于获取 monitor 的所有权，monitorexit 指令用于释放 monitor 的所有权。 JVM 会确保 monitorenter 和 monitorexit 指令是成对出现的，即使在发生异常的情况下，也会确保锁被释放，从而避免死锁。 早期的synchronized效率比较低，因为是重量级锁，会涉及到用户态和内核态的切换，开销较大。但是现在JVM对synchronized做了很多优化，比如锁升级，轻量级锁，偏向锁等，在很多场景下synchronized的效率已经很高了。

以上就是《Java同步锁怎么用？手把手教你synchronized的4种正确姿势》的详细内容，更多关于java的资料请关注golang学习网公众号！