synchroized与Lock的区别

**同步(Synchronized) 与 Lock 的区别**

在 Java 中，同步和锁（Lock）是两种常见的用于实现线程安全性的机制。虽然它们都可以用来保护共享资源，但它们有着不同的使用方式和性能特点。

###1. 同步(Synchronized)

同步是通过在方法或代码块上加锁来实现的。Java 提供了 `synchronized` 关键字，可以用于修饰类、方法或代码块。同步机制会自动地为每个线程分配一个锁，当多个线程试图访问同一资源时，会导致线程阻塞。

####1.1 同步的优点* 简单易用：只需在需要保护的方法或代码块上加锁即可。
* 自动管理锁：不需要手动释放锁，减少了编码负担。

####1.2 同期的缺点* 性能开销较大：每次进入同步区都需要进行锁的获取和释放操作，这会带来一定的性能损失。
* 不灵活：同步机制不支持多种粒度的锁定，例如只保护某个变量而不是整个方法。

###2. 锁(Lock)

锁是通过手动管理锁来实现的。Java 提供了 `ReentrantLock` 类，可以用于替代传统的 `synchronized` 锁。锁机制允许程序员自行控制锁的获取和释放，提供更灵活的线程安全性实现。

####2.1 锁的优点* 高性能：手动管理锁可以减少锁的获取和释放操作，从而提高系统的整体性能。
* 灵活度高：支持多种粒度的锁定，例如只保护某个变量而不是整个方法。

####2.2 锁的缺点* 复杂性增加：需要手动管理锁，增加了编码负担和错误风险。
* 需要额外的资源：锁机制可能会占用系统资源，如内存或CPU时间。

###3.代码示例####3.1 同步示例

javapublic class SynchronizedExample {
 private int count =0;

 public synchronized void increment() {
 count++;
 }

 public static void main(String[] args) throws InterruptedException {
 final SynchronizedExample example = new SynchronizedExample();
 Thread thread1 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });
 Thread thread2 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();

 System.out.println("Final count: " + example.count);
 }
}

javaimport java.util.concurrent.locks.ReentrantLock;

public class LockExample {
 private int count =0;
 private final ReentrantLock lock = new ReentrantLock();

 public void increment() {
 lock.lock();
 try {
 count++;
 } finally {
 lock.unlock();
 }
 }

 public static void main(String[] args) throws InterruptedException {
 final LockExample example = new LockExample();
 Thread thread1 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });
 Thread thread2 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();

 System.out.println("Final count: " + example.count);
 }
}