Java之线程篇二

Java之线程篇二：多线程的同步与并发控制

在上一篇中，我们了解了Java中的线程基础，包括线程的创建和启动。这一篇将重点讨论多线程中的同步与并发控制机制，以确保在多线程环境下数据的一致性和安全性。

1. 同步的必要性

在多线程编程中，多个线程可能会同时访问共享资源。如果没有适当的同步机制，就会导致数据不一致的问题。举个例子，假设我们有一个账户，多个线程同时进行存取款操作，可能会出现错误的余额计算。

2. synchronized关键字

Java提供了synchronized关键字来实现同步。它可以用于方法或代码块，确保同一时刻只有一个线程可以访问被保护的资源。

以下是一个简单的账户类，演示了synchronized的使用：

class Account {
    private int balance = 0;

    // 存款方法
    public synchronized void deposit(int amount) {
        balance += amount;
    }

    // 取款方法
    public synchronized void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
        }
    }

    // 查询余额
    public int getBalance() {
        return balance;
    }
}

在上述代码中，deposit和withdraw方法都是用synchronized修饰的，这样在同一时间内，只有一个线程可以调用这两个方法，有效地保证了余额的正确性。

3. 显式锁：ReentrantLock

除了synchronized，Java还提供了更灵活的锁机制——ReentrantLock，它允许我们对线程的获取与释放锁进行更细粒度的控制。例如，我们可以通过tryLock()方法尝试获取锁，这对于避免死锁非常有用。

以下是一个使用ReentrantLock的例子：

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

class AccountWithLock {
    private int balance = 0;
    private Lock lock = new ReentrantLock();

    public void deposit(int amount) {
        lock.lock();  // 获取锁
        try {
            balance += amount;
        } finally {
            lock.unlock();  // 释放锁
        }
    }

    public void withdraw(int amount) {
        lock.lock();  // 获取锁
        try {
            if (balance >= amount) {
                balance -= amount;
            }
        } finally {
            lock.unlock();  // 释放锁
        }
    }

    public int getBalance() {
        return balance;
    }
}

在这个示例中，ReentrantLock的使用增强了代码的可读性和可维护性，同时也避免了因异常而导致的锁未释放的问题。

4. 读写锁

在许多应用场景中，读多写少的情况很常见。Java中的ReadWriteLock能够在这种场景下提高并发性能。它允许多个线程同时读取资源，但在写入资源时，必须获得独占锁。

以下是一个使用ReadWriteLock的例子：

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

class ReadWriteAccount {
    private int balance = 0;
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public void deposit(int amount) {
        lock.writeLock().lock();
        try {
            balance += amount;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public void withdraw(int amount) {
        lock.writeLock().lock();
        try {
            if (balance >= amount) {
                balance -= amount;
            }
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int getBalance() {
        lock.readLock().lock();
        try {
            return balance;
        } finally {
            lock.readLock().unlock();
        }
    }
}

在这个示例中，写操作需要获取写锁，而读取操作只需要获取读锁。这种策略大大提升了并发度。

5. 总结

在Java的多线程编程中，正确的同步与并发控制机制至关重要。通过使用synchronized、ReentrantLock和ReadWriteLock，我们能够有效地管理共享资源的访问，确保数据的一致性与安全性。接下来的篇章中，我们将继续探讨其他多线程相关的主题，比如线程池和任务调度，敬请期待。