Day20_1--多线程锁学习之synchronized和Lock

当谈到多线程编程时，同步和锁是非常重要的概念。Java 提供了多种机制来实现线程之间的同步，其中包括 synchronized 关键字和 Lock 接口的实现类。本文将介绍如何使用这些机制来确保线程安全性和避免竞态条件。

1. synchronized 关键字

Java 中最基本的同步机制是使用 synchronized 关键字来修饰方法或代码块。synchronized 可以应用于实例方法、静态方法以及代码块。

示例：

public class SynchronizedExample {

    private int count = 0;

    // 同步实例方法
    public synchronized void increment() {
        count++;
    }

    // 非同步方法
    public void printCount() {
        System.out.println("Count: " + count);
    }

    // 同步代码块
    public void synchronizedBlock() {
        synchronized (this) {
            // 访问共享资源的代码
            count++;
        }
    }
}

在上面的示例中，increment() 方法和 synchronizedBlock() 方法都是同步的，它们使用了 synchronized 关键字来确保在同一时刻只有一个线程可以访问共享资源 count。这种方式简单易懂，但有时候灵活性较差。

2. Lock 接口和 ReentrantLock 类

除了 synchronized 关键字，Java 还提供了 Lock 接口及其实现类来实现更加灵活的同步机制。其中最常用的实现类是 ReentrantLock，它提供了比 synchronized 更多的操作方式，如尝试获取锁、超时获取锁等。

示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {

    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 获取锁
        try {
            count++;
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public void printCount() {
        System.out.println("Count: " + count);
    }
}

在这个示例中，increment() 方法使用了 ReentrantLock 来确保 count 的线程安全性。在使用 Lock 的时候，务必在 try 块中获取锁，在 finally 块中释放锁，以确保锁的正确使用，避免死锁等问题。

3. 同步 vs Lock

• 灵活性：Lock 接口提供了比 synchronized 更多的功能，如尝试获取锁、超时获取锁等，使得在复杂场景下更加灵活。
• 性能：在某些情况下，Lock 的性能可能比 synchronized 更好，特别是在高并发情况下。
• 可读性：synchronized 关键字相对更加简单直观，适合简单的同步需求。

4. 注意事项

• 避免死锁：多线程编程中常见的问题之一是死锁，即多个线程相互等待对方持有的锁。要避免死锁，可以按照固定的顺序获取锁。
• 性能考量：Lock 比 synchronized 更加复杂，应在确实需要其额外功能时才使用，否则优先考虑 synchronized 关键字。