【JAVA多线程】JDK中的各种锁，看这一篇就够了

在Java中，多线程编程是一个非常重要的编程主题，尤其是在处理共享资源时，锁的使用变得至关重要。Java中提供了多种锁机制，以满足不同场景下的需求。本文将介绍JDK中各种锁的类型及其使用方法，帮助你更好地理解Java多线程中的锁。

1. 内置锁（监视器锁）

在Java中，每个对象都有一个内置锁，也称为监视器锁。在同步代码块或同步方法中，JVM会自动获取对象的锁。在同一时刻，只有获得锁的线程可以执行这部分代码，而其他线程则需等待。

示例代码：

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

public class TestSynchronized {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + counter.getCount());
    }
}

2. ReentrantLock

ReentrantLock是一个实现了Lock接口的锁，提供了比内置锁更灵活的锁机制。它具有可重入性、可中断性和公平性等特点。使用ReentrantLock可以指定锁的公平性，公平锁会使得所有线程按照请求锁的顺序进行排队。

示例代码：

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

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

    public int getCount() {
        return count;
    }
}

public class TestReentrantLock {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + counter.getCount());
    }
}

3. 读写锁（ReadWriteLock）

ReadWriteLock允许多个读线程同时访问共享资源，但在写线程访问时，必须独占资源。它提高了性能，尤其是读取操作频繁的场景。

示例代码：

import java.util.concurrent.locks.ReentrantReadWriteLock;

class Data {
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private int value;

    public void setValue(int value) {
        rwLock.writeLock().lock();
        try {
            this.value = value;
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    public int getValue() {
        rwLock.readLock().lock();
        try {
            return value;
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

public class TestReadWriteLock {
    public static void main(String[] args) {
        Data data = new Data();
        Runnable reader = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Value: " + data.getValue());
            }
        };

        Runnable writer = () -> {
            for (int i = 0; i < 5; i++) {
                data.setValue(i);
                System.out.println("Set Value: " + i);
            }
        };

        Thread t1 = new Thread(reader);
        Thread t2 = new Thread(writer);
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4. 其他锁

除了上述锁，Java还提供了其他锁机制，例如StampedLock，它提供了一种乐观锁机制，适用于读多写少的场景。还可以使用Semaphore和CountDownLatch等对象来控制线程的执行。

总结

在Java中，线程同步是多线程编程中的一项重要任务。通过不同的锁机制，开发者可以根据具体的业务需求选择合适的锁，以提高程序的性能和可靠性。理解这些锁的特点及用法，可以帮助我们编写出高效且安全的多线程应用。