多线程同步问题：Java中线程间互斥锁的使用示例

原创落日映苍穹つ 2024-09-27 17:42 51阅读 0赞

在Java中，互斥锁（Mutex）是一种同步原语，用于保护共享资源不受并发访问的破坏。

以下是一个简单的多线程互斥锁使用示例：

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

class SharedResource {
    private int count = 0;

// 读操作
    public int read() {
        lock();
        try {
            return count++;
        } finally {
            unlock();
        }
    }

// 写操作，需要互斥锁保护
    public void write(int value) {
        lock();
        try {
            count = value;
        } finally {
            unlock();
        }
    }

private void lock() {
        lockObj = new Object();
        synchronized (lockObj) {
        }
    }

private void unlock() {
        synchronized (lockObj) {
            lockObj.notifyAll();
        }
    }

// 锁对象，用于同步
    private Lock lockObj;
}

public class ThreadMutexExample {
    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

// 创建两个线程，分别进行读和写操作
        Thread thread1 = new Thread(() -> sharedResource.read()));
        Thread thread2 = new Thread(() -> sharedResource.write(10)));

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

try {
            // 等待所有线程完成执行
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Final count: " + sharedResource.read());  // 这里会输出最终的计数，应与写操作前一致
    }
}
```

在这个示例中，我们创建了一个共享资源`SharedResource`，它有一个可以被读写的计数器。然后我们创建了两个线程，一个进行读操作，另一个进行写操作。

通过互斥锁（ReentrantLock），确保在任何时候只有一个线程能够访问`SharedResource`的内部状态，从而保证了数据的一致性。