Java Lock 入门

在多线程编程中，正确地管理并发访问资源对于保证程序的正确性和效率至关重要。Java 提供了一种多样化的锁（Lock）机制来协助开发者实现线程同步和互斥控制。本文将深入探讨 Java 中的锁机制，涵盖基础概念、使用方法、常见实践和最佳实践，以帮助读者深入理解并高效使用 Java Lock。

目录

1. 简介
2. Java Lock 基础概念
3. Java Lock 使用方法
4. Java Lock 常见实践
5. Java Lock 最佳实践
6. 小结
7. 参考资料

简介

锁用于管理对共享资源的访问，防止多个线程同时进入临界区（critical section）以避免数据争用（race condition）。Java 在 java.util.concurrent 包中提供了多种锁实现，用以替代传统的 synchronized 块，具备更灵活的锁定机制及更好的性能表现。

Java Lock 基础概念

Java 中的锁主要由 Lock 接口及其实现类构成。与 synchronized 相比，Lock 接口提供了更高级的锁定操作。常见的锁实现包括：

• ReentrantLock: 可重入锁，具有与隐式监视器锁（synchronized）相同的基本行为和语义。

• ReadWriteLock: 读写锁，允许多个读线程同时持有读锁，但写锁是独占的。

• StampedLock: 一种乐观读的锁，实现锁的升级和降级操作，以提升高并发环境下的性能。

Java Lock 使用方法

使用 ReentrantLock

ReentrantLock 是最常用的锁之一，其使用非常简单。下面是一个基本示例：

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

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();
    private int counter = 0;

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

    public int getCounter() {
        return counter;
    }
}

使用 ReadWriteLock

ReadWriteLock 提供了一个适合应对读多写少场景的锁：

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

public class ReadWriteLockExample {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private int counter = 0;

    public void increment() {
        rwLock.writeLock().lock();
        try {
            counter++;
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    public int getCounter() {
        rwLock.readLock().lock();
        try {
            return counter;
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

使用 StampedLock

StampedLock 提供了额外的优势，可以在高并发需求下提供更好的性能：

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private final StampedLock stampedLock = new StampedLock();
    private int counter = 0;

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

    public int getCounter() {
        long stamp = stampedLock.tryOptimisticRead();
        int currentCounter = counter;
        if (!stampedLock.validate(stamp)) {
            stamp = stampedLock.readLock();
            try {
                currentCounter = counter;
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        return currentCounter;
    }
}

Java Lock 常见实践

1. 避免锁嵌套：锁嵌套容易导致死锁问题。必须避免在实现中使用多个锁持有顺序。

2. 合理选择锁类型：根据场景选择合适的锁类型，例如在读多写少的场景中使用 ReadWriteLock 。

3. 及时释放锁：务必在 finally 块中释放锁，保证程序异常情况下锁能被正确释放。

Java Lock 最佳实践

• 使用 try-lock 进行超时控制：避免长时间获取不到锁而导致线程挂起，可以使用 tryLock(long timeout, TimeUnit unit) 方法。

• 合适粒度的锁：锁的粒度过大会降低并行度，而过小又可能导致频繁的锁争用，需要在性能和安全性之间取得平衡。

• 乐观读：在高并发环境中，可以通过 StampedLock 的乐观读来尽量减少写锁的使用。

小结

Java 的锁机制为多线程开发提供了丰富和灵活的同步策略。根据应用场景，合理选择和使用锁，可以有效提高应用的并行性和资源的利用效率。

参考资料

1. Java Documentation - Lock Interface
2. Java Concurrency in Practice - Brian Goetz
3. Effective Java - Joshua Bloch