Java线程同步引用基本代码介绍("Java线程同步基础：核心代码解析与实践介绍")

原创

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

Java线程同步基础：核心代码解析与实践介绍

一、Java线程同步概述

在Java多线程编程中，线程同步是一个非常重要的概念。线程同步关键是为了解决多个线程在访问共享资源时也许出现的数据不一致和竞态条件问题。Java提供了多种同步机制，如synchronized关键字、ReentrantLock、读写锁等。本文将重点解析Java线程同步的核心代码及其实践应用。

二、synchronized关键字

synchronized关键字是Java线程同步的基础，它可以修饰方法或代码块。当一个线程访问一个对象的synchronized方法或代码块时，其他线程必须等待该线程执行完毕才能访问相同的同步代码。

2.1 同步方法

同步方法是指使用synchronized关键字修饰的方法。当一个线程访问一个对象的同步方法时，其他线程不能同时访问该对象的任何同步方法。


public synchronized void synchronizedMethod() {
    // 同步代码
}

2.2 同步代码块

同步代码块是指使用synchronized关键字修饰的代码块。它可以指定一个锁对象，当线程访问该代码块时，需要获取锁对象的锁。


public void synchronizedBlock() {
    synchronized(this) {
        // 同步代码
    }
}

三、ReentrantLock

ReentrantLock是Java提供的一个显式锁实现，它比synchronized关键字提供了更多彩的功能，如可中断的锁获取、尝试非阻塞地获取锁、拥护公平锁等。

3.1 基本使用

使用ReentrantLock时，需要显式创建锁对象，并通过lock()方法获取锁，通过unlock()方法释放锁。


public void reentrantLockExample() {
    ReentrantLock lock = new ReentrantLock();
    lock.lock();
    try {
        // 同步代码
    } finally {
        lock.unlock();
    }
}

3.2 可中断的锁获取

ReentrantLock提供了lockInterruptibly()方法，允许线程在等待获取锁的过程中被中断。


public void reentrantLockInterruptibleExample() throws InterruptedException {
    ReentrantLock lock = new ReentrantLock();
    try {
        lock.lockInterruptibly();
        // 同步代码
    } finally {
        lock.unlock();
    }
}

四、读写锁（ReadWriteLock）

读写锁是一种特殊的锁，它允许多个线程同时读取共享资源，但在写入共享资源时需要独占锁。Java提供了ReadWriteLock接口及其实现类ReentrantReadWriteLock。

4.1 基本使用

使用读写锁时，需要创建ReadWriteLock对象，并通过readLock()和writeLock()方法分别获取读锁和写锁。


public void readWriteLockExample() {
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    Lock readLock = readWriteLock.readLock();
    Lock writeLock = readWriteLock.writeLock();
    // 获取读锁
    readLock.lock();
    try {
        // 读取共享资源
    } finally {
        readLock.unlock();
    }
    // 获取写锁
    writeLock.lock();
    try {
        // 写入共享资源
    } finally {
        writeLock.unlock();
    }
}

五、线程同步实践案例

下面通过一个易懂的示例来演示线程同步的应用。假设有一个银行账户类Account，包含存款和取款方法，为了保证操作的原子性，我们需要使用同步机制。

5.1 Account类实现


public class Account {
    private double balance;
    public Account(double balance) {
        this.balance = balance;
    }
    public synchronized void deposit(double amount) {
        balance += amount;
    }
    public synchronized void withdraw(double amount) throws InterruptedException {
        if (amount > balance) {
            throw new InterruptedException("Insufficient funds");
        }
        balance -= amount;
    }
    public double getBalance() {
        return balance;
    }
}

5.2 线程同步实践

下面创建两个线程，一个线程负责存款，另一个线程负责取款，通过同步方法确保操作的原子性。


public class Main {
    public static void main(String[] args) throws InterruptedException {
        Account account = new Account(1000);
        Thread depositThread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                account.deposit(100);
            }
        });
        Thread withdrawThread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    account.withdraw(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        depositThread.start();
        withdrawThread.start();
        depositThread.join();
        withdrawThread.join();
        System.out.println("Final balance: " + account.getBalance());
    }
}