多线程同步问题：Java中线程间的互斥、信号量等问题实例

原创﹏ヽ暗。殇╰゛Y 2024-09-16 06:04 9阅读 0赞

在Java中，线程间的互斥和同步主要通过以下几种机制实现：

1. **synchronized关键字**：
   - `synchronized(this)`：锁定当前对象。
   - `synchronized(object, lock))`：锁住指定的Lock。

2. **wait()与notify()方法**：
   - 线程在执行任务过程中发现需要等待，调用`wait()`方法。
   - 主线程通过调用`notify()`或`notifyAll()`方法唤醒等待中的线程。

3. **Semaphore信号量**：
   - 信号量是一种同步原语，可以控制多个互斥资源的访问。
   - 当一个信号量的值大于0时，线程可以通过`await(sem);`来获取该资源并进入等待状态。

实例代码如下：

```java
// 线程1，需要锁住资源A
class Thread1 implements Runnable {
    private Lock lock = new ReentrantLock();
    
    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println("Thread 1: Acquiring resource A");
            // 执行任务
            Thread.sleep(2000); // 模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            System.out.println("Thread 1: Releasing resource A");
        }
    }
}

// 线程2，需要锁住资源B
class Thread2 implements Runnable {
    private Lock lock = new ReentrantLock();

@Override
    public void run() {
        lock.lock();
        try {
            System.out.println("Thread 2: Acquiring resource B");
            // 执行任务
            Thread.sleep(1000); // 模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            System.out.println("Thread 2: Releasing resource B");
        }
    }
}

// 主程序，创建线程并控制同步
public class Main {
    public static void main(String[] args) {
        // 创建锁对象
        Lock lock = new ReentrantLock();

// 创建两个需要互斥的线程
        Thread thread1 = new Thread1();
        Thread thread2 = new Thread2();

// 启动线程
        thread1.start();
        thread2.start();

// 主程序结束，解锁资源
        try {
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上代码示例中，线程1需要获取资源A并执行任务，线程2则需要获取资源B并执行任务。通过ReentrantLock实现多线程间的互斥和同步控制。