并发编程困惑：Java多线程同步与互斥示例

原创本是古典何须时尚 2024-11-12 21:18 38阅读 0赞

在Java中，多线程编程是一个复杂的话题，涉及到线程的创建、管理和同步。同步和互斥是确保多线程程序正确执行的关键概念。下面我将通过一个简单的示例来解释Java中的多线程同步与互斥。

###同步（Synchronization）

同步是控制多个线程访问共享资源的一种机制。在Java中，可以通过`synchronized`关键字来实现同步。当一个线程访问一个对象的`synchronized`方法或代码块时，它会获得该对象的锁，其他线程则不能访问该对象的任何`synchronized`方法或代码块，直到当前线程释放锁。

#### 示例代码：

```javapublic class Counter {
 private int count =0;

// synchronized方法 public synchronized void increment() {
 count++;
 }

public synchronized int getCount() {
 return count;
 }
}

public class ThreadExample {
 public static void main(String[] args) {
Counter counter = new Counter();

Thread t1 = new Thread(() -> {
 for (int i =0; i <1000; i++) {
 counter.increment();
 }
 });

Thread t2 = new Thread(() -> {
 for (int i =0; i <1000; i++) {
 counter.increment();
 }
 });

t1.start();
t2.start();

try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
 }

System.out.println("Final count is: " + counter.getCount());
 }
}
```在这个例子中，`Counter`类有一个`count`变量和一个`increment`方法，该方法被`synchronized`修饰，确保了每次只有一个线程可以增加`count`的值。

###互斥（Mutual Exclusion）

互斥是确保在任何时候只有一个线程可以访问某个资源的状态。在Java中，这通常通过锁机制来实现，比如`ReentrantLock`。

#### 示例代码：

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

public class Counter {
 private final Lock lock = new ReentrantLock();
 private int count =0;

public void increment() {
lock.lock();
 try {
 count++;
} finally {
lock.unlock();
 }
 }

public int getCount() {
 return count;
 }
}

public class ThreadExample {
 public static void main(String[] args) {
Counter counter = new Counter();

Thread t1 = new Thread(() -> {
 for (int i =0; i <1000; i++) {
 counter.increment();
 }
 });

Thread t2 = new Thread(() -> {
 for (int i =0; i <1000; i++) {
 counter.increment();
 }
 });

t1.start();
t2.start();

try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
 }

System.out.println("Final count is: " + counter.getCount());
 }
}
```在这个例子中，我们使用了`ReentrantLock`来确保`increment`方法的互斥访问。`lock.lock()`获取锁，`lock.unlock()`释放锁，确保了在任何时候只有一个线程可以增加`count`的值。

这两个示例都展示了如何在Java中实现线程同步和互斥，以确保线程安全。