Java并发编程：线程安全方法的实例分析

原创拼搏现实的明天。 2024-10-23 22:57 1阅读 0赞

在Java并发编程中，线程安全是指一个方法或者类在多线程环境下执行时，不会因共享资源而出现数据不一致的问题。

以下是一些线程安全的方法实例：

1. 同步方法：
   ```java
   class Counter {
       private int count = 0;

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

public synchronized int getCount() {
           return count;
       }
   }
   ```
2. 同步块（synchronized关键字）：
   ```java
   class BankAccount {
       private double balance = 0;

public void deposit(double amount) {
           synchronized(this) { // 使用同步块
               if(amount > 0) {
                   balance += amount;
               } else {
                   System.out.println("Deposit cannot be negative.");
               }
           }
       }

public void withdraw(double amount) {
           synchronized(this) { // 使用同步块
               if(amount > 0 && balance >= amount) { // 检查金额是否在余额范围内
                   balance -= amount;
                   } else {
                       System.out.println("Withdrawal exceeds available balance.");
                   }
           }
       }

public double getBalance() {
           return balance;
       }
   }
   ```
3. 使用Java内置的并发工具类，如`ConcurrentHashMap`和`ExecutorService`：
   ```java
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;

class ParallelCounter {
       private ConcurrentHashMap<String, Integer> counterMap = new ConcurrentHashMap<>();

public void increment(String key) {
           ExecutorService executor = Executors.newFixedThreadPool(1);
           executor.execute(() -> { // 使用线程池来并发执行
               counterMap.putIfAbsent(key, 0); // 如果键不存在，则添加键值对
               counterMap.increment(key); // 增加键对应的值
           }});
       }

public int getCount(String key) {
           return counterMap.getOrDefault(key, 0));
       }
   }
   ```
以上实例展示了如何在Java中使用同步方法和工具类来确保线程安全。