并发世界的秘密武器——Java并发工具类大揭秘

在多线程编程的广阔天地中，我们面对的不仅仅是速度与激情的碰撞，更是秩序与混乱的较量。Java语言以其强大的并发工具集，成为这场较量中的制胜法宝。本篇，我们将深入探讨ReentrantLock和Semaphore，并展示它们如何帮助我们构建安全、高效的并发应用程序。

第一章：深入ReentrantLock：从独占到共享的锁

在并发编程中，锁是用来保护共享资源免受多线程干扰的关键。而ReentrantLock，作为java.util.concurrent.locks包中的一员，提供了比synchronized关键字更灵活、更强大的控制能力。

1.1 独占锁的使用

让我们首先来看一个简单的银行账户转账场景，这里我们将使用ReentrantLock来确保在任何时刻只有一个线程能够修改账户余额。

import java.util.concurrent.locks.ReentrantLock;

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

    public void transfer(BankAccount other, int amount) {
        lock.lock();
        try {
            if (balance >= amount) {
                balance -= amount;
                other.deposit(amount);
                System.out.println("转账成功，余额：" + balance);
            } else {
                System.out.println("余额不足，无法转账");
            }
        } finally {
            lock.unlock();
        }
    }

    private void deposit(int amount) {
        balance += amount;
    }
}

1.2 共享锁的探索

除了独占锁，ReentrantLock还支持共享锁模式，允许多个读操作同时进行，但写操作仍需独占。这在读多写少的场景下特别有用，因为多个读线程不会相互阻塞。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class DataStore {
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private int data;

    public int readData() {
        ReentrantReadWriteLock.ReadLock rlock = rwl.readLock();
        rlock.lock();
        try {
            return data;
        } finally {
            rlock.unlock();
        }
    }

    public void writeData(int value) {
        ReentrantReadWriteLock.WriteLock wlock = rwl.writeLock();
        wlock.lock();
        try {
            data = value;
        } finally {
            wlock.unlock();
        }
    }
}

---

第二章：信号量的力量：Semaphore的妙用

当需要限制访问某个资源的线程数量时，Semaphore便派上了用场。例如，在一个爬虫程序中，我们可能不希望同时有太多线程访问同一服务器，以免造成不必要的压力。

2.1 使用Semaphore控制并发数

下面的代码展示了如何使用Semaphore来限制同时运行的任务数量。

import java.util.concurrent.Semaphore;

public class TaskExecutor {
    private final Semaphore semaphore = new Semaphore(5); // 控制并发数为5

    public void execute(Runnable task) {
        semaphore.acquireUninterruptibly(); // 非中断请求许可
        try {
            task.run();
        } finally {
            semaphore.release(); // 完成后释放许可
        }
    }
}

2.2 Semaphore与线程池的结合

结合线程池，我们可以进一步优化任务执行的效率，确保即使在高并发环境下，也能合理分配资源。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class TaskExecutor {
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
    private final Semaphore semaphore = new Semaphore(5);

    public void execute(Runnable task) {
        semaphore.acquireUninterruptibly();
        try {
            executor.execute(() -> {
                try {
                    task.run();
                } finally {
                    semaphore.release();
                }
            });
        } catch (RejectedExecutionException e) {
            semaphore.release(); // 如果线程池已满，释放许可
        }
    }
}