多线程中的锁: 掌控同步的神器

2024-01-07 11:19:16

多线程编程中的锁机制

在多线程编程中，锁是至关重要的同步机制，它确保了共享资源在并发访问时的安全性和一致性。了解和正确使用锁对于构建可靠且高效的多线程应用程序至关重要。

互斥锁：独占访问的守护者

互斥锁，也称为“普通锁”，提供了一种简单而有效的方式来确保对共享资源的独占访问。当一个线程获取互斥锁时，它可以不受其他线程干扰地访问受保护的资源。

public class Counter {
    private final Object lock = new Object();
    private int value;

    public void increment() {
        synchronized (lock) {
            value++;
        }
    }
}

互斥锁非常适合保护那些只能由一个线程同时访问的资源。它们易于理解和使用，但需要小心使用，因为它们可能导致死锁。

递归锁：重入锁定的利器

递归锁是一种更高级别的互斥锁，允许线程对同一锁进行多次获取。这在某些场景中非常有用，例如递归数据结构的遍历。

public class RecursiveCounter {
    private final ReentrantLock lock = new ReentrantLock();
    private int value;

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

递归锁允许同一个线程多次获取锁，避免了死锁。它们还可中断，这在处理外部事件时很有用。

条件锁：同步等待的信号灯

条件锁允许线程在满足特定条件时等待并被唤醒。这对于协调线程之间的交互和实现生产者-消费者模式非常有用。

public class ProducerConsumerQueue {
    private final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
    private final Condition notEmpty = queue.newCondition();
    private final Condition notFull = queue.newCondition();

    public void produce(int item) {
        try {
            notFull.await();
            queue.put(item);
            notEmpty.signal();
        } catch (InterruptedException e) {
            // 处理中断
        }
    }

    public int consume() {
        try {
            notEmpty.await();
            int item = queue.take();
            notFull.signal();
            return item;
        } catch (InterruptedException e) {
            // 处理中断
        }
    }
}