浅聊一下Java中的锁机制

Java中的锁机制是保证多线程并发访问共享资源安全性的重要手段之一。Java提供了两种类型的锁机制：synchronized关键字和Lock接口。本文将介绍这两种锁机制的原理及使用方法，并通过代码示例讲解它们的使用。

synchronized关键字

synchronized关键字是Java语言内置的一种锁机制，它可以用来实现对代码块或方法的同步控制。synchronized可以保证在同一时刻只有一个线程可以执行被锁定的代码块或方法，其他线程则需要等待锁释放后才能继续执行。这种机制可以避免多个线程同时对共享资源进行操作而引发的数据不一致问题。

原理

synchronized锁的实现依赖于Java对象头中的Mark Word（标记字段）。每个Java对象都有一个Mark Word，用于存储对象的元数据信息。synchronized锁就是利用Mark Word中的标志位来实现的。当一个线程获取锁时，它会将对象头中的标志位设置为锁定状态，其他线程在尝试获取锁时，发现标志位已被设置为锁定状态，就会进入等待状态，直到锁被释放。

使用方法

synchronized可以用来修饰代码块和方法，具体用法如下：

代码块同步

synchronized (lockObject) {
    // 需要同步的代码块
}

其中，lockObject是一个Java对象，用来作为锁对象。当线程进入同步块时，它会尝试获取lockObject对象的锁，如果锁已被其他线程持有，则该线程会进入等待状态，直到锁被释放。

方法同步

public synchronized void method() {
    // 需要同步的代码
}

当一个线程调用被synchronized修饰的方法时，它会尝试获取当前对象的锁，如果锁已被其他线程持有，则该线程会进入等待状态，直到锁被释放。需要注意的是，方法同步只对同一对象有效，对不同对象的方法调用并不会互斥。

代码示例

下面是一个使用synchronized关键字实现线程同步的示例代码。该代码定义了一个Counter类，包含一个count属性和两个方法：increment()和decrement()，分别用于对count进行加1和减1操作。increment()和decrement()方法都使用synchronized关键字进行同步，以确保对count的操作是线程安全的。

public class Counter {
    private int count;
​
    public synchronized void increment() {
        count++;
    }
​
    public synchronized void decrement() {
        count--;
    }
​
    public int getCount() {
        return count;
    }
}

Lock接口

除了synchronized关键字外，Java还提供了Lock接口来实现锁机制。相对于synchronized，Lock接口提供了更加灵活的锁定方式和更加精细的控制，例如可以实现公平锁和非公平锁、可重入锁等。

原理

Lock接口的实现原理和synchronized类似，都是通过占用对象的锁来实现同步控制。不同的是，Lock接口提供了更多的方法来控制锁的获取和释放，例如tryLock()方法可以尝试获取锁，如果获取失败则不会阻塞线程，而是直接返回。

使用方法

Lock接口的使用相对比较复杂，需要注意锁的获取和释放时机，以避免死锁等问题。下面是一个简单的Lock接口使用示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
​
public class Counter {
    private int count;
    private Lock lock = new ReentrantLock();
​
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
​
    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }
​
    public int getCount() {
        return count;
    }
}

在上述代码中，我们使用了ReentrantLock类来实现Lock接口。在increment()和decrement()方法中，我们使用了lock()方法获取锁，使用了unlock()方法释放锁。需要注意的是，为了避免线程因异常而无法释放锁，我们将获取锁和释放锁的代码放在了try...finally块中。

公平锁与非公平锁

Lock接口的实现可以是公平锁（FairLock）或非公平锁（NonFairLock）。公平锁指的是锁的获取是按照请求的先后顺序进行的，而非公平锁则不保证锁的获取顺序。在实际应用中，公平锁可以保证所有线程都有平等的机会获取锁，但是会降低性能，因为线程需要等待前面的线程释放锁；而非公平锁则可能会导致某些线程一直无法获取锁，但是会提高性能，因为线程可以不需要等待直接获取锁。

可重入锁

Lock接口还提供了可重入锁（ReentrantLock），它可以允许一个线程多次获取同一把锁。这种锁机制可以避免死锁等问题，并且可以提高代码的可读性和可维护性。例如，在某个方法中调用了另一个同步方法，如果使用synchronized关键字，需要在内部方法中再次获取锁才能保证线程安全；而使用可重入锁则可以直接调用。

Lock接口提供了更多的方法来控制锁的获取和释放，例如tryLock()方法可以尝试获取锁，如果获取失败则不会阻塞线程，而是直接返回；lockInterruptibly()方法可以在获取锁时响应中断，可以有效避免死锁等问题。

代码示例

下面是一个使用Lock接口实现读写锁的示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
​
public class MyReadWriteLock {
    private int value;
    private ReadWriteLock lock = new ReentrantReadWriteLock();
    private Lock readLock = lock.readLock();
    private Lock writeLock = lock.writeLock();
​
    public int getValue() {
        readLock.lock();
        try {
            return value;
        } finally {
            readLock.unlock();
        }
    }
​
    public void setValue(int value) {
        writeLock.lock();
        try {
            this.value = value;
        } finally {
            writeLock.unlock();
        }
    }
}

在上述代码中，我们使用了ReentrantReadWriteLock类来实现读写锁。读写锁可以同时支持多个读操作，但只能有一个写操作，因此可以提高代码的并发性能。在getValue()方法中，我们使用了读锁来获取当前的value值，而在setValue()方法中，我们使用了写锁来设置新的value值。

总结

Lock接口相对于synchronized关键字提供了更加灵活的锁定方式和更加精细的控制。使用Lock接口可以避免死锁等问题，并且可以提高代码的可读性和可维护性。在实际应用中，需要注意锁的获取和释放时机，以避免死锁等问题。同时，还需要根据实际情况选择公平锁和非公平锁，以及可重入锁等不同的锁类型。