多线程（45）Java中的锁优化-CSDN博客

本文链接：https://blog.csdn.net/qq_43012298/article/details/136768476

Java中的锁是并发编程中保证数据一致性和线程安全的重要机制。随着Java平台的发展，锁的性能和功能也在不断提升。然而，不当的锁使用仍然可能导致性能瓶颈。以下是一些Java中锁优化的技巧，结合源码和代码演示，帮助你更高效地使用锁。

1. 减少锁的粒度

锁的粒度指的是锁保护的代码区域大小。较大的锁粒度意味着更多的代码被锁保护，可能导致线程等待时间增加。减少锁的粒度可以提高应用性能。

示例：假设有一个类用来统计用户登录次数：

public class UserLoginCounter {
    private final Map<String, Integer> loginCount = new HashMap<>();
    
    public synchronized void incrementLoginCount(String userId) {
        loginCount.put(userId, loginCount.getOrDefault(userId, 0) + 1);
    }
}

在这个例子中，incrementLoginCount方法是synchronized的，这意味着每次只有一个线程可以更新计数。如果有大量用户，这将成为性能瓶颈。可以通过减少锁的粒度来优化：

public class UserLoginCounter {
    private final Map<String, Integer> loginCount = new ConcurrentHashMap<>();
    
    public void incrementLoginCount(String userId) {
        loginCount.compute(userId, (key, val) -> (val == null) ? 1 : val + 1);
    }
}

使用ConcurrentHashMap可以让多个线程并发更新不同用户的登录计数，从而减小了锁的粒度。

2. 使用锁分段技术

锁分段是一种减少锁粒度的技术，它将数据结构分成多段，每段有自己的锁。这样，不同的线程可以同时访问不同段的数据。

ConcurrentHashMap在内部就使用了锁分段技术。每个段是独立的，有自己的锁，从而允许多个线程并发访问不同段的元素。

3. 使用非阻塞算法

传统的锁是阻塞的，当线程尝试获得一个已被其他线程持有的锁时，它将被挂起。非阻塞算法，比如CAS(compare-and-swap)，提供了一种不同的方法，线程可以在不被挂起的情况下重试操作。

Java的AtomicInteger类就是使用CAS实现的一个例子。

public class Counter {
    private final AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();
    }
}

使用AtomicInteger的incrementAndGet方法可以安全地增加计数，无需使用synchronized关键字，且性能通常比锁要好。

4. 优化锁的持有时间

减少锁的持有时间可以显著提高并发性能。尽量确保锁只保护临界区代码，并且临界区尽可能小。

public class MyObject {
    private Object data;
    private final Object lock = new Object();
    
    public void updateData(Object newData) {
        synchronized(lock) {
            // 尽量减少这里的代码量
            data = newData;
        }
        // 其他不需要同步的操作
    }
}

5. 读写锁分离

当多个线程对数据的读操作远多于写操作时，使用ReadWriteLock可以带来更好的性能。ReadWriteLock允许多个线程同时读取数据，但只有一个线程可以写入数据。

public class DataContainer {
    private Object data;
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Lock readLock = rwLock.readLock();
    private final Lock writeLock = rwLock.writeLock();
    
    public Object readData() {
        readLock.lock();
        try {
            return data;
        } finally {
            readLock.unlock();
        }
    }
    
    public void writeData(Object newData) {
        writeLock.lock();
        try {
            data = newData;
        } finally {
            writeLock.unlock();
        }
    }
}