Java并发编程：线程安全问题实例分析

原创电玩女神 2024-09-16 06:03 98阅读 0赞

在Java的多线程环境中，线程安全是一个关键的概念。线程安全是指一个对象在多线程环境下正确执行不会产生意外结果的状态。

以下是一些具体的线程安全问题实例：

1. **共享变量的修改**：
   ```java
   class Counter {
       int count = 0;
       
       public synchronized void increment() {
           count++;
           notifyAll(); // 通知所有等待的线程
       }
       
       public synchronized void decrement() {
           if (count > 0) {
               count--;
               if (count == 0) { // 如果计数为零，则唤醒等待的线程
                   notifyAll();
               }
           }
       }
   }
   
   public class TestCounter {
       Counter counter = new Counter();

public void increment() {
           synchronized (counter) {
               counter.increment();
           }
       }

public void decrement() {
           synchronized (counter) {
               counter.decrement();
           }
       }

public static void main(String[] args) {
           TestCounter test = new TestCounter();
   
           // 创建多个线程并发操作
           for (int i = 0; i < 10; i++) {
               Thread t = new Thread(() -> {
                   test.increment(); // 同时尝试增加计数
               }));
               t.start();
           }

// 等待所有线程执行完毕
           for (Thread t : Thread.getAllThreads())) {
               if (!t.isAlive()) { // 如果线程已经结束，那么我们可以进行下一步操作
                   try {
                       t.join(); // 等待线程执行完毕
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }

System.out.println("Counter count: " + counter.count)); // 运行后检查计数是否正确
       }
   }
   ```
   
2. **静态变量的并发访问**：
   ```java
   class Singleton {
       private static Singleton instance = new Singleton();

public static Singleton getInstance() {
           return instance;
       }

private Singleton() {} // 使构造方法不可见，确保唯一实例
   }
   
   public class TestSingleton {
       public void testInstance() {
           assert Singleton.getInstance() == Singleton.getInstance(); // 检查是否为同一个对象
       }
       
       public static void main(String[] args) {
           TestSingleton ts = new TestSingleton();
           
           ts.testInstance(); // 运行测试用例
       }
   }
   ```
   
这些都是Java并发编程中常见的线程安全问题。理解和解决这些问题，对于编写高效、可靠的多线程程序至关重要。