大佬们好！我是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());
}
}
小结
在 Java 中，有多种方式可以实现线程安全：使用 synchronized 关键字、使用 Atomic 类以及使用 ReentrantLock。每种方法都适用于不同的场景，开发者可以根据需求选择合适的方式：
- synchronized：适用于方法或代码块的同步，但它的性能可能较低。
- Atomic 类：提供高效的原子操作，适用于简单的数值操作。
- ReentrantLock：提供了更细粒度的锁控制，适用于需要更灵活锁机制的场景。
通过合理选择和使用这些线程安全工具，开发者可以有效地管理并发操作，确保程序的正确性和高效性。
好啦，废话不多说，今天的分享就到这里！如果你觉得我这“初级马牛”还挺有趣，那就请给我点个赞、留个言、再三连击三连哦！让我们一起“成精”吧！下次见，不见不散！
