当前位置：首页 > news >正文

Java后端中的并发控制：从锁机制到无锁编程的实现

news 2025/6/27 9:17:01

Java后端中的并发控制：从锁机制到无锁编程的实现

大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨Java后端开发中非常重要的一部分内容——并发控制。在多线程环境下，如何保证数据一致性和程序的正确性是我们面临的主要挑战。本文将通过对锁机制的深入介绍，并引入无锁编程的实现方式，帮助大家掌握并发编程中的核心技术。

一、Java中的锁机制

在Java中，锁（Lock）是控制多线程并发的重要工具，它用于确保共享资源在同一时间只能被一个线程访问。最基础的同步机制是synchronized关键字，它为方法或代码块提供了一种隐式锁。

1. synchronized的使用

synchronized关键字可以修饰方法或代码块，用于保证某个线程在执行代码块时，其他线程不能进入相同的代码块。

示例代码：

package cn.juwatech.concurrent;public class SynchronizedExample {private int count = 0;public synchronized void increment() {count++;}public int getCount() {return count;}public static void main(String[] args) {SynchronizedExample example = new SynchronizedExample();Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();}});thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final count: " + example.getCount());}
}

在这段代码中，increment()方法通过synchronized关键字保证了线程安全。然而，synchronized的粒度较粗，会阻塞其他线程进入同步代码块，因此在并发量较高时可能会影响性能。

2. ReentrantLock的使用

ReentrantLock是java.util.concurrent.locks包中的锁，它提供了更灵活的锁机制，比如可中断锁等待、非阻塞锁获取等。

示例代码：

package cn.juwatech.concurrent;import java.util.concurrent.locks.ReentrantLock;public class ReentrantLockExample {private final ReentrantLock lock = new ReentrantLock();private int count = 0;public void increment() {lock.lock();try {count++;} finally {lock.unlock();}}public int getCount() {return count;}public static void main(String[] args) {ReentrantLockExample example = new ReentrantLockExample();Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();}});thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final count: " + example.getCount());}
}

这里使用了ReentrantLock来代替synchronized，我们显式调用lock()和unlock()来控制锁的获取与释放。相比synchronized，ReentrantLock允许更灵活的锁操作，例如支持公平锁和非公平锁的选择。

二、无锁编程的实现

虽然锁机制能保证线程安全，但在高并发环境下，锁的竞争可能导致性能瓶颈。为了进一步提升并发性能，可以考虑使用无锁编程。Java的java.util.concurrent.atomic包提供了许多原子操作类，例如AtomicInteger、AtomicReference等，它们通过硬件层面的CAS（Compare And Swap）操作来实现线程安全，而无需使用锁。

1. 使用AtomicInteger实现无锁递增

通过AtomicInteger，我们可以避免使用锁来实现线程安全的递增操作。

示例代码：

package cn.juwatech.concurrent;import java.util.concurrent.atomic.AtomicInteger;public class AtomicIntegerExample {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet();}public int getCount() {return count.get();}public static void main(String[] args) {AtomicIntegerExample example = new AtomicIntegerExample();Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {example.increment();}});thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final count: " + example.getCount());}
}

通过AtomicInteger，可以避免锁的使用，同时保证并发操作的原子性。这种无锁编程方式适用于对性能要求较高的场景，特别是轻量级的操作。

2. 使用AtomicReference实现无锁对象更新

除了基本的数值类型，AtomicReference可以帮助我们实现对对象的无锁更新。

示例代码：

package cn.juwatech.concurrent;import java.util.concurrent.atomic.AtomicReference;public class AtomicReferenceExample {private static class Account {private String name;private int balance;public Account(String name, int balance) {this.name = name;this.balance = balance;}public String getName() {return name;}public int getBalance() {return balance;}public void setBalance(int balance) {this.balance = balance;}}private AtomicReference<Account> account = new AtomicReference<>(new Account("Alice", 1000));public void updateBalance(int newBalance) {Account currentAccount;Account newAccount;do {currentAccount = account.get();newAccount = new Account(currentAccount.getName(), newBalance);} while (!account.compareAndSet(currentAccount, newAccount));}public Account getAccount() {return account.get();}public static void main(String[] args) {AtomicReferenceExample example = new AtomicReferenceExample();Thread thread1 = new Thread(() -> {example.updateBalance(1200);});Thread thread2 = new Thread(() -> {example.updateBalance(1500);});thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final balance: " + example.getAccount().getBalance());}
}

这里我们通过AtomicReference实现了账户余额的无锁更新。compareAndSet()方法会在内部循环，直到成功更新对象，这种方式避免了锁的开销。

三、StampedLock和ReadWriteLock

在读多写少的场景中，传统的排它锁可能会造成大量线程的等待，因此Java提供了读写锁机制来优化这类场景。ReadWriteLock允许多个线程同时读取数据，而写操作则会独占锁。

1. ReadWriteLock示例

package cn.juwatech.concurrent;import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReadWriteLockExample {private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();private int value = 0;public int readValue() {rwLock.readLock().lock();try {return value;} finally {rwLock.readLock().unlock();}}public void writeValue(int newValue) {rwLock.writeLock().lock();try {value = newValue;} finally {rwLock.writeLock().unlock();}}public static void main(String[] args) {ReadWriteLockExample example = new ReadWriteLockExample();Thread writer = new Thread(() -> {example.writeValue(100);});Thread reader = new Thread(() -> {System.out.println("Read value: " + example.readValue());});writer.start();reader.start();try {writer.join();reader.join();} catch (InterruptedException e) {e.printStackTrace();}}
}