并发挑战：Java多线程编程与同步问题实例

原创左手的ㄟ右手 2024-12-11 10:18 34阅读 0赞

在Java多线程编程中，我们经常面临并发挑战和同步问题。以下是一些实例：

1. **竞态条件**：
   当多个线程访问同一块资源（如共享变量、文件等）并可能同时修改该资源时，就会出现竞态条件。
   
   ```java
   // 竞态条件示例：两个线程共享一个count变量
   class Counter {
       int count = 0;
       
       void increment() {
           synchronized (this) { // 使用synchronized关键字解决同步问题
               count++;
           }
       }
       
       // 获取当前计数
       int getCount() {
           return count;
       }
   }
   
   Thread t1 = new Thread(() -> Counter.increment(counter)));
   Thread t2 = new Thread(() -> System.out.println(counter.getCount())));

counter = new Counter();
   t1.start();
   t2.start();
   ```
   
2. **死锁**：
   当两个或更多的线程在执行过程中，因互相等待对方释放资源而造成的一种状态即为死锁。
   
   ```java
   // 死锁示例：两个线程分别持有A和B资源，但是它们都需要对方释放资源才能继续执行
   class Resource {
       String name;
       
       Resource(String name) {
           this.name = name;
       }
   }
   
   class ThreadA extends Thread {
       Resource rA;
       
       ThreadA(Resource rA) {
           this.rA = rA;
       }
       
       @Override
       public void run() {
           while (true) { // 无限循环，模拟资源无法自动释放的情况
               if (rA.name.equals("A")) && (ThreadB.rB.name.equals("B"))) {
                   System.out.println("线程A释放资源A，等待线程B释放资源B...");
                   break; // 等待线程B释放资源
               }
           }
       }
   }
   
   class ThreadB extends Thread {
       Resource rB;
       
       ThreadB(Resource rB) {
           this.rB = rB;
       }
       
       @Override
       public void run() {
           while (true) { // 无限循环，模拟资源无法自动释放的情况
               if (rA.name.equals("A")) && (ThreadB.rB.name.equals("B"))) {
                   System.out.println("线程B释放资源B，等待线程A释放资源A...");
                   break; // 等待线程A释放资源
               }
           }
       }
   }
   
   Resource rA = new Resource("A");
   Resource rB = new Resource("B");
   
   ThreadA taA = new ThreadA(rA);
   ThreadB tbB = new ThreadB(rB);
   
   taA.start();
   tbB.start();
   
   // 无限循环，等待线程释放资源
   while (true) {
       try {
           Thread.sleep(100); // 等待时间，模拟实际情况
           break; // 当前循环结束，等待下一轮循环继续执行
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
   ```

以上例子展示了多线程编程中可能遇到的并发挑战和同步问题。通过理解和掌握这些概念，开发者可以编写更高效、更可靠的多线程程序。