Java中的并发锁是什么，提供一个使用并发锁的实际案例("Java并发锁详解及实际应用案例")

原创

ithorizon 7个月前 (10-20) 阅读数 17 #后端开发

Java并发锁详解及实际应用案例

一、Java中的并发锁是什么

在Java中，并发锁（Concurrency Lock）是一种用于控制多个线程对共享资源访问的同步机制。并发锁确保在同一时刻，只有一个线程可以执行某个特定的代码块或方法，从而避免多线程并发时产生的竞争条件（Race Condition）。

Java提供了多种锁机制，包括内置锁（Intrinsic Lock，例如synchronized关键字）、显示锁（Explicit Lock，例如ReentrantLock类）等。这些锁机制可以帮助开发者有效地管理并发访问，确保线程保险。

二、并发锁的分类

Java中的并发锁关键分为以下几类：

内置锁（Intrinsic Lock）：通过synchronized关键字实现，每个Java对象都可以作为锁。

显示锁（Explicit Lock）：通过Lock接口及其实现类（如ReentrantLock）实现，提供了更充裕的锁操作。

读写锁（ReadWriteLock）：通过ReadWriteLock接口实现，分为读锁（共享锁）和写锁（排他锁）。

条件锁（Condition）：与ReentrantLock结合使用，提供类似Object.wait()和Object.notify()的功能。

三、实际应用案例：银行账户转账

以下是一个使用并发锁的实际案例，模拟银行账户转账的过程。我们将使用ReentrantLock作为锁机制，确保转账操作的线程保险。

3.1 账户类 Account

账户类包含账户余额和锁对象，提供存款、取款和查询余额的方法。


public class Account {
    private double balance;
    private final ReentrantLock lock = new ReentrantLock();
    public Account(double balance) {
        this.balance = balance;
    }
    public void deposit(double amount) {
        lock.lock();
        try {
            balance += amount;
        } finally {
            lock.unlock();
        }
    }
    public void withdraw(double amount) {
        lock.lock();
        try {
            if (balance >= amount) {
                balance -= amount;
            }
        } finally {
            lock.unlock();
        }
    }
    public double getBalance() {
        return balance;
    }
}

3.2 转账类 Transfer

转账类包含两个账户对象和一个锁对象，提供转账方法。


public class Transfer {
    private final Account fromAccount;
    private final Account toAccount;
    private final ReentrantLock lock = new ReentrantLock();
    public Transfer(Account fromAccount, Account toAccount) {
        this.fromAccount = fromAccount;
        this.toAccount = toAccount;
    }
    public void transfer(double amount) {
        lock.lock();
        try {
            if (fromAccount.getBalance() >= amount) {
                fromAccount.withdraw(amount);
                toAccount.deposit(amount);
            }
        } finally {
            lock.unlock();
        }
    }
}

3.3 测试类 Test

测试类创建多个线程，模拟多个账户之间的转账操作。


public class Test {
    public static void main(String[] args) {
        Account account1 = new Account(1000);
        Account account2 = new Account(1000);
        Transfer transfer = new Transfer(account1, account2);
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                transfer.transfer(100);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                transfer.transfer(100);
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Account 1 balance: " + account1.getBalance());
        System.out.println("Account 2 balance: " + account2.getBalance());
    }
}