Java多线程并发编程：同步机制与实践应用

引言

在Java编程领域，多线程并发编程扮演着举足轻重的角色。随着计算机硬件多核处理器的普及，充分利用多线程提升程序性能、实现高效的任务处理与资源共享成为关键技能。然而，多线程编程并非一帆风顺，若处理不当，数据不一致、竞态条件等问题便会接踵而至。本文聚焦Java多线程中的同步机制，深入剖析其原理、应用场景，并结合详实代码示例展现其魅力与要点。

一、多线程并发引发的问题

当多个线程同时访问共享资源（如类的成员变量、静态变量等），若无有效管控，会催生诸多棘手状况。以经典的“银行账户余额存取”场景为例，定义如下简单类模拟账户操作：

class BankAccount {
   
    private int balance;

    public BankAccount(int initialBalance) {
   
        this.balance = initialBalance;
    }

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

    public void withdraw(int amount) {
   
        balance -= amount;
    }

    public int getBalance() {
   
        return balance;
    }
}

 

 

若多个线程并发执行存取款操作，像这样创建线程执行：

public class Main {
   
    public static void main(String[] args) {
   
        BankAccount account = new BankAccount(1000);
        Thread thread1 = new Thread(() -> {
   
            for (int i = 0; i < 100; i++) {
   
                account.deposit(10);
            }
        });
        Thread thread2 = new Thread(() -> {
   
            for (int i = 0; i < 50; i++) {
   
                account.withdraw(20);
            }
        });
        thread1.start();
        thread2.start();
        try {
   
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        System.out.println("最终账户余额: " + account.getBalance());
    }
}

 

 

多次运行会发现，最终账户余额并非预期固定值，原因在于deposit和withdraw方法执行时，balance变量读写操作被多线程交叉干扰，产生数据不一致，此即典型竞态条件导致错误结果。

二、同步机制之synchronized关键字

为化解上述问题，Java提供synchronized关键字，它基于对象锁实现同步。有两种基本使用方式：修饰方法与修饰代码块。

（一）修饰方法

修改BankAccount类的存取款方法如下：

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

public synchronized void withdraw(int amount) {
   
    balance -= amount;
}

 

 

synchronized修饰后，同一时刻仅有一个线程能进入此方法访问balance变量，其他线程需等待锁释放。这种方式简单直接，适用于方法内操作均涉及共享资源且逻辑紧密场景，但粒度稍粗，有时影响并发性能。

（二）修饰代码块

更灵活精细控制可借助修饰代码块达成，改写BankAccount示例：

public void deposit(int amount) {
   
    synchronized (this) {
   
        balance += amount;
    }
}

public void withdraw(int amount) {
   
    synchronized (this) {
   
        balance -= amount;
    }
}

 

 

这里synchronized (this)以当前对象实例（this）作为锁对象，进入代码块前线程获取锁，块内独占共享资源访问权，块执行完释放锁。相较修饰方法，能精准把控需同步代码范围，降低锁竞争、提升并发度，比如方法内存在非共享资源操作可置于同步块外并行执行。

三、ReentrantLock显式锁

除synchronized，Java.util.concurrent包下ReentrantLock提供显式锁功能，用法如下：

import java.util.concurrent.locks.ReentrantLock;

class BankAccountWithLock {
   
    private int balance;
    private ReentrantLock lock = new ReentrantLock();

    public BankAccountWithLock(int initialBalance) {
   
        this.balance = initialBalance;
    }

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

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

    public int getBalance() {
   
        return balance;
    }
}

 

 

ReentrantLock通过lock方法获取锁、unlock释放锁，必须在finally块确保解锁以避免死锁隐患。它优势在于功能丰富，如支持可中断锁获取（lockInterruptibly）、尝试非阻塞获取锁（tryLock），适用于复杂同步逻辑、需精细控制锁获取与释放流程场景，为开发者赋予更多控制权应对多样并发需求。

四、同步机制高级应用：读写锁

处理读多写少场景，ReentrantReadWriteLock读写锁登场，能分离读、写锁，允许多个线程并发读共享资源提升效率，同时写操作独占资源保数据一致性。示例：

import java.util.concurrent.locks.ReentrantReadWriteLock;

class DataStore {
   
    private int data;
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();

    public int readData() {
   
        readLock.lock();
        try {
   
            return data;
        } finally {
   
            readLock.unlock();
        }
    }

    public void writeData(int newData) {
   
        writeLock.lock();
        try {
   
            this.data = newData;
        } finally {
   
            writeLock.unlock();
        }
    }
}

 

 

多个线程调用readData可并行，而writeData执行时独占锁，读写高效协调，契合如缓存数据频繁读取、偶尔更新场景。