并发编程挑战：Java多线程下同步与互斥示例

原创曾经终败给现在 2024-12-01 09:42 15阅读 0赞

在Java的多线程环境中，同步和互斥是两个重要的概念。它们主要用于防止多个线程同时访问或修改共享资源。

1. **同步（Synchronization）**：
   - `synchronized`关键字：用于修饰方法或者代码块，确保同一时间只有一个线程可以执行。
   ```java
   // 以对象为锁
   class Counter {
       private int count = 0;
       
       synchronized void increment() {
           count++;
       }
       
       synchronized int getCount() {
           return count;
       }
   }
   
   // 使用synchronized修饰的方法
   Counter counter = new Counter();
   Thread thread1 = new Thread(() -> counter.increment()));
   Thread thread2 = new Thread(() -> System.out.println(counter.getCount())));
   
   thread1.start();  // 启动线程1
   thread2.start();  // 同时启动线程2

// 结束后，打印出计数值
   thread1.join();
   thread2.join();
   System.out.println(counter.getCount());  // 输出：1
   ```

2. **互斥（Mutual Exclusion）**：
   - 当两个或多个线程需要访问一个共享资源，并且只有一个线程可以访问该资源时，就会涉及到互斥问题。
   
在Java中，通过`java.util.concurrent.locks.Lock`和`Lockable`接口来实现互斥。常见的锁有`ReentrantLock`、`Semaphore`等。

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ExclusiveResource {
    private Lock lock = new ReentrantLock();

// 互斥方法，只有一个线程可以执行
    public void accessExclusiveResource() throws InterruptedException {
        lock.lock();  // 获取锁

try {
            // 在这里进行需要独占资源的操作
            System.out.println("Accessing exclusive resource...");

// 需要等待操作完成后释放锁
            Thread.sleep(2000);  // 假设操作需要花费时间
        } finally {
            lock.unlock();  // 释放锁
        }
    }

public static void main(String[] args) {
        ExclusiveResource resource = new ExclusiveResource();
        
        // 启动两个线程尝试访问独占资源
        Thread thread1 = new Thread(() -> resource.accessExclusiveResource()));
        Thread thread2 = new Thread(() -> resource.accessExclusiveResource()));

thread1.start();  // 启动第一个线程
        thread2.start();  // 同时启动第二个线程

// 等待所有线程执行完毕
        thread1.join();
        thread2.join();

System.out.println("Exclusive resource access completed.");  // 结束后输出信息
    }
}
```

以上代码示例中，我们使用了`ReentrantLock`作为互斥锁。每个线程在访问独占资源时，都需要先获取锁，然后进行操作，最后释放锁。

这样设计的互斥机制可以确保任何时候只有一个线程可以访问共享资源，避免了数据不一致的问题。