如何在 Java 中使用线程安全的类

大佬们好！我是LKJ_Coding，一枚初级马牛，正在努力在代码的丛林中找寻自己的方向。如果你也曾在调试中迷失，或是在文档中翻滚，那我们一定有许多共同话题可以聊！今天，我带着满满的代码“干货”来和大家分享，学不学无所谓，反正我先吐槽了！

概述：线程安全类的概念

线程安全（Thread Safety） 是指多个线程并发访问某个类时，该类的行为能够保持正确性和一致性，不会因为多线程的竞争导致程序错误或数据不一致。在多线程编程中，线程安全性是一个非常重要的概念，因为多个线程共享数据和资源时，如果没有合适的同步措施，可能会导致线程之间的数据冲突、竞态条件等问题。

Java 提供了多种方式来实现线程安全，包括：

使用 synchronized 关键字：确保方法或代码块在同一时刻只有一个线程可以执行。
使用 Atomic 类：通过原子操作保证数据的一致性。
使用 ReentrantLock：通过显式的锁管理来控制多线程访问。

在本篇文章中，我们将介绍如何在 Java 中使用线程安全的类，具体包括：

使用 synchronized 关键字保证方法的线程安全。
使用 Atomic 类和 ReentrantLock 实现线程安全。
通过代码示例展示如何使用这些工具管理并发操作。

synchronized 关键字

synchronized 关键字是 Java 中实现线程安全的一种常见方式，它可以用来修饰方法或者代码块，确保在同一时刻只有一个线程能够访问被修饰的部分。

1. 使用 `synchronized` 关键字保证方法线程安全

示例：使用 `synchronized` 修饰实例方法

public class Counter {private int count = 0;// 使用 synchronized 关键字确保该方法在同一时刻只有一个线程可以访问public synchronized void increment() {count++;}public synchronized void decrement() {count--;}public int getCount() {return count;}
}public class TestSynchronized {public static void main(String[] args) {Counter counter = new Counter();// 启动多个线程进行并发操作Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.decrement();}});thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final count: " + counter.getCount());}
}

在这个示例中，increment() 和 decrement() 方法都使用了 synchronized 关键字，确保在多个线程访问时，方法内部的操作是原子的。synchronized 关键字锁定了当前对象，保证只有一个线程可以在同一时刻访问该方法。

示例：使用 `synchronized` 修饰静态方法

如果方法是静态的，synchronized 会锁定类的 Class 对象，而不是当前实例。

public class StaticCounter {private static int count = 0;// 使用 synchronized 修饰静态方法public static synchronized void increment() {count++;}public static synchronized void decrement() {count--;}public static int getCount() {return count;}
}

2. 使用 `synchronized` 修饰代码块

除了修饰方法，synchronized 还可以用于修饰代码块。这种方式可以提高性能，因为它只锁定特定代码块，而不是整个方法。

示例：使用 `synchronized` 修饰代码块

public class Counter {private int count = 0;public void increment() {synchronized (this) {count++;}}public void decrement() {synchronized (this) {count--;}}public int getCount() {return count;}
}

这种方式的优点是可以锁定方法中的特定代码块，从而减少锁的范围，提高性能。

Atomic 类和 ReentrantLock

1. Atomic 类

Atomic 类是 Java 提供的一系列类（如 AtomicInteger、AtomicLong、AtomicReference 等），它们通过原子操作来保证数据的一致性和线程安全。原子操作意味着在多线程环境下，不会被中断或干扰，保证操作的完整性。

示例：使用 `AtomicInteger` 实现线程安全

import java.util.concurrent.atomic.AtomicInteger;public class AtomicCounter {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet();  // 原子性地递增}public void decrement() {count.decrementAndGet();  // 原子性地递减}public int getCount() {return count.get();}
}public class TestAtomic {public static void main(String[] args) {AtomicCounter counter = new AtomicCounter();// 启动多个线程进行并发操作Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.decrement();}});thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final count: " + counter.getCount());}
}

在这个示例中，AtomicInteger 的 incrementAndGet() 和 decrementAndGet() 方法提供了原子操作，确保多线程环境下的安全性，无需显式使用 synchronized。

2. ReentrantLock

ReentrantLock 是 Java 中的显式锁，它提供了更灵活和强大的锁机制，相比于 synchronized 关键字，ReentrantLock 可以实现更细粒度的控制，如尝试锁定、定时锁定、非阻塞锁定等功能。

示例：使用 `ReentrantLock` 实现线程安全

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class LockCounter {private int count = 0;private final Lock lock = new ReentrantLock();public void increment() {lock.lock();  // 获取锁try {count++;} finally {lock.unlock();  // 释放锁}}public void decrement() {lock.lock();  // 获取锁try {count--;} finally {lock.unlock();  // 释放锁}}public int getCount() {return count;}
}public class TestReentrantLock {public static void main(String[] args) {LockCounter counter = new LockCounter();// 启动多个线程进行并发操作Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.increment();}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {counter.decrement();}});thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final count: " + counter.getCount());}
}

在这个示例中，ReentrantLock 的 lock() 和 unlock() 方法用于显式地控制线程对共享资源的访问。lock() 方法会获取锁，unlock() 方法释放锁。finally 块确保锁在方法执行完后释放，即使发生异常也能释放锁。

代码示例：使用线程安全类管理并发操作

public class ThreadSafeExample {public static void main(String[] args) {final LockCounter lockCounter = new LockCounter();final AtomicCounter atomicCounter = new AtomicCounter();// 使用 ReentrantLock 的线程Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {lockCounter.increment();}});// 使用 AtomicInteger 的线程Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {atomicCounter.increment();}});thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final count with ReentrantLock: " + lockCounter.getCount());System.out.println("Final count with AtomicInteger: " + atomicCounter.getCount());}
}