多线程锁

在并发编程中,锁(Lock)是一种用于控制多个线程对共享资源访问的机制。正确使用锁可以确保数据的一致性和完整性,避免出现竞态条件(Race Condition)、死锁(Deadlock)等问题。Java 提供了多种类型的锁来满足不同场景下的需求,从内置的对象锁到更高级别的 java.util.concurrent.locks 包中的显式锁。

为什么需要锁?

当多个线程同时尝试修改同一份数据时,如果没有适当的同步措施,可能会导致以下问题:

  • 数据不一致:不同的线程读取到了部分更新的数据。
  • 丢失更新:一个线程的更改被另一个线程覆盖。
  • 脏读/写:线程读取或写入了尚未完成的操作。

为了解决这些问题,我们需要一种机制来协调线程之间的访问顺序,保证每次只有一个线程能够操作共享资源。这就是锁的作用所在。

Java 中的锁类型

内置锁(Intrinsic Lock)

也称为监视器锁(Monitor Lock),是通过关键字 synchronized 实现的。每个对象都有一个与之关联的内置锁,当一个线程进入由 synchronized 修饰的方法或代码块时,它会自动获取该对象的锁;而当方法执行完毕或遇到 wait() 调用时,则会释放锁。

public synchronized void method() {
    // 只有一个线程可以进入这里
}
public void method() {
    synchronized (this) {
        // 同样只有一个线程可以进入这里
    }
}

显式锁(Explicit Lock)

从 Java 5 开始,java.util.concurrent.locks 包引入了更为灵活和强大的锁接口——Lock。相比于内置锁,显式锁提供了更多的功能,如可中断的锁等待、超时获取锁以及公平锁等特性。

ReentrantLock

ReentrantLock 是最常用的显式锁实现之一,它允许同一个线程多次获取同一把锁,并且必须按照获取的次数逐一释放。这使得递归调用成为可能。

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

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

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 确保无论如何都会解锁
        }
    }

    public int getCount() {
        return count;
    }
}
ReadWriteLock

ReadWriteLock 接口定义了一种读写分离的锁机制,其中读锁允许多个线程同时持有,但不允许写锁存在;反之,一旦有线程持有了写锁,其他所有试图获取读锁或写锁的线程都将被阻塞。这种设计非常适合读多写少的情况。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Cache {
    private final Map<String, Object> map = new HashMap<>();
    private final ReadWriteLock rwl = new ReentrantReadWriteLock();

    public Object get(String key) {
        rwl.readLock().lock();
        try {
            return map.get(key);
        } finally {
            rwl.readLock().unlock();
        }
    }

    public void put(String key, Object value) {
        rwl.writeLock().lock();
        try {
            map.put(key, value);
        } finally {
            rwl.writeLock().unlock();
        }
    }
}
StampedLock

StampedLock 是 Java 8 新增的一种乐观锁,它结合了读写锁的功能并提供了更好的性能优化。它支持三种模式:读、写和乐观读。乐观读模式假设不会有冲突发生,因此不会阻塞其他线程;但如果检测到冲突,则需要回滚操作并重新尝试。

import java.util.concurrent.locks.StampedLock;

public class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    void move(double deltaX, double deltaY) { 
        long stamp = sl.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    double distanceFromOrigin() { 
        long stamp = sl.tryOptimisticRead();
        double currentX = x, currentY = y;
        if (!sl.validate(stamp)) {
            stamp = sl.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

锁的使用原则

  • 最小化锁定范围:尽量减少加锁的时间和区域,只保护真正需要保护的资源。
  • 避免死锁:设计时要特别小心,防止形成循环等待链,即多个线程互相持有对方所需的锁。
  • 使用超时机制:对于可能长时间阻塞的操作,考虑设置合理的超时时间以提高系统的健壮性。
  • 优先选择高级并发工具:相比于原始的内置锁,应该更多地利用 java.util.concurrent 包中提供的高级工具,因为它们通常更加安全可靠且易于使用。
  • 文档化锁协议:清晰地记录各个锁之间的关系和使用规则,有助于后续维护人员理解代码逻辑。

最佳实践案例

使用 ReentrantLock 替代内置锁

在某些情况下,ReentrantLock 可以为我们提供比内置锁更多的灵活性。例如,它可以让我们实现非阻塞的锁尝试 (tryLock) 或者带超时的锁等待 (tryLock(long timeout, TimeUnit unit)).

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

public class BankAccount {
    private double balance;
    private final Lock lock = new ReentrantLock();

    public boolean withdraw(double amount) throws InterruptedException {
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                if (balance >= amount) {
                    balance -= amount;
                    return true;
                }
            } finally {
                lock.unlock();
            }
        }
        return false; // 超时未获得锁或余额不足
    }
}

使用 ReadWriteLock 优化读多写少场景

当应用程序中有大量读操作而写操作相对较少时,ReadWriteLock 可以显著提升性能,因为它允许多个线程同时进行读取,而不必像内置锁那样每次都排他地占用资源。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ConcurrentCache<K, V> {
    private final Map<K, V> cache = new ConcurrentHashMap<>();
    private final ReadWriteLock rwl = new ReentrantReadWriteLock();

    public V get(K key) {
        rwl.readLock().lock();
        try {
            return cache.get(key);
        } finally {
            rwl.readLock().unlock();
        }
    }

    public void put(K key, V value) {
        rwl.writeLock().lock();
        try {
            cache.put(key, value);
        } finally {
            rwl.writeLock().unlock();
        }
    }
}

使用 StampedLock 进行乐观读

对于那些读操作远多于写操作,并且读操作之间几乎没有竞争的应用程序来说,StampedLock 的乐观读模式可以提供更高的吞吐量。它首先尝试无锁读取,只有在检测到潜在冲突时才会退回到传统的读锁方式。

import java.util.concurrent.locks.StampedLock;

public class OptimisticCounter {
    private long count = 0;
    private final StampedLock sl = new StampedLock();

    public long readCount() {
        long stamp = sl.tryOptimisticRead();
        long localCount = count;
        if (!sl.validate(stamp)) {
            stamp = sl.readLock();
            try {
                localCount = count;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return localCount;
    }

    public void increment() {
        long stamp = sl.writeLock();
        try {
            count++;
        } finally {
            sl.unlockWrite(stamp);
        }
    }
}

结语

感谢您的阅读!如果您对多线程锁或其他并发编程话题有任何疑问或见解,欢迎继续探讨。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值