并发控制：Java线程同步问题示例

原创一时失言乱红尘 2024-10-21 17:21 36阅读 0赞

在Java中，线程同步主要是通过各种锁机制实现的。以下是一些常见的并发控制问题及示例：

1. **死锁**：
   当两个或多个线程相互等待对方释放资源时，就会发生死锁。
   示例代码（无限循环导致死锁）：
   ```java
   // 线程A
   class ThreadA extends Thread {
       private Lock lockA = new ReentrantLock();

public void run() {
           lockA.lock();
           try {
               while (true) {
                   System.out.println("Thread A: Looping...");
               }
           } finally {
               lockA.unlock();
           }
       }
   }

// 线程B
   class ThreadB extends Thread {
       private Lock lockB = new ReentrantLock();

public void run() {
           lockB.lock();
           try {
               while (true) {
                   System.out.println("Thread B: Looping...");
               }
           } finally {
               lockB.unlock();
           }
       }
   }

public class Main {
       public static void main(String[] args) {
           ThreadA threadA = new ThreadA();
           ThreadB threadB = new ThreadB();

threadA.start();
           threadB.start();

// 等待线程结束
           while (!threadA.isFinished() && !threadB.isFinished())) {
               try {
                   // 控制程序的执行，等待线程结束
                   Thread.sleep(1000); // 模拟长时间操作
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

System.out.println("Both threads have finished.");
       }
   }
```
在这个示例中，线程A和线程B都无限循环地执行任务。当程序主线程运行到`Thread.sleep(1000);`这一行时，会睡眠1秒，模拟长时间操作。

当任意一个线程完成其无限循环后，会释放锁并打印一条信息。主线程此时会从睡眠中唤醒，继续执行后续的逻辑。