synchronized关键字在Java中用于实现线程同步，确保多线程并发访问共享资源时的互斥执行。其主要使用方式包括：1. 同步代码块，通过指定对象作为锁；2. 同步方法，锁为当前对象（this）或类对象（class）；3. 静态同步方法，等价于使用类对象作为锁；4. 同步静态变量，通常使用静态对象作为锁。此外，synchronized依赖jvm的monitor机制，通过monitorenter和monitorexit指令实现锁的获取与释放，并在jdk 1.6后通过锁优化提升了性能。相比reentrantlock，synchronized是隐式锁，自动释放，而reentrantlock需要手动释放且提供更多功能，但更易出错。避免死锁的方法包括统一锁顺序、限制锁持有时间、使用定时锁及工具检测。
synchronized关键字在Java中用于实现线程同步，确保多个线程在并发访问共享资源时，只有一个线程可以执行特定代码块或方法，从而避免数据竞争和不一致性。它本质上提供了一种互斥锁机制。
解决方案
synchronized关键字主要有四种使用方式：
立即学习“Java免费学习笔记（深入）”；
-
同步代码块（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对象，同步就无效了。
-
同步方法（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; } } -
同步静态变量（不常用）：
虽然不常见，但也可以通过同步静态变量来实现同步。 这本质上和同步代码块使用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; } } -
隐式锁（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的效率已经很高了。
