Java并发编程：线程安全方法及实例

原创待我称王封你为后i 2024-09-16 06:03 62阅读 0赞

在Java中，线程安全（thread-safe）是指一个方法或代码块在多线程环境下执行时不会导致数据的不一致。以下是一些线程安全的方法和实例：

1. 同步块/方法（synchronized）
```java
// 示例：共享资源counter
public class Counter {
    private int count;

public synchronized void increment() {
        count++;
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new RuntimeException("Can't decrement from zero!");
        }
    }

public synchronized int getCount() {
        return count;
    }
}
```
2. 静态内部类（static inner class）
```java
// 示例：线程安全的事件监听器
public class EventMonitor {
    private final Object lock = new Object();

// 线程安全的方法
    public void addListener(int eventCode) {
        synchronized (lock) {
            if (!eventCodes.contains(eventCode))) {
                eventCodes.add(eventCode);
                System.out.println("Event " + eventCode + " added to listener list.");
            }
        }
    }

// 线程安全的获取方法
    public List<Integer> getEventListenerCodes() {
        synchronized (lock) {
            return new ArrayList<>(eventCodes);
        }
    }
}
```
3. 使用`java.util.concurrent.locks.Lock`和`Condition`
```java
// 示例：使用ReentrantLock实现线程安全操作
import java.util.concurrent.locks.ReentrantLock;

public class ThreadSafeExample {
    private final ReentrantLock lock = new ReentrantLock();

// 线程安全的方法
    public void safeMethod() {
        lock.acquire(); // 请求锁

try {
            // 进行线程安全的操作
            System.out.println("Thread-safe operation performed.");
        } finally {
            lock.release(); // 释放锁
        }
    }
}
```
通过上述例子，你可以看到如何使用Java的并发工具来确保方法在多线程环境下的正确性。