Java多线程通信问题示例

原创桃扇骨 2024-12-06 05:18 2阅读 0赞

在Java中，多线程通信主要通过一些特定的同步机制来实现。以下是两个常见的通信示例：

1. **共享变量同步**：
```java
public class SharedVariableSync {
    private int count = 0; // 共享变量

// 线程A：增加计数
    public void threadA() {
        while (true) { // 没有明确结束条件，模拟无限循环
            if (count % 2 == 1) { // 计数为奇数时
                count++; // 增加计数
            }
            if (count >= 10) { // 当计数达到10时，跳出循环
                break;
            }
        }
    }

// 线程B：减少计数
    public void threadB() {
        while (true) { // 没有明确结束条件，模拟无限循环
            if (count % 2 == 0) { // 计数为偶数时
                count--; // 减少计数
            }
            if (count <= 5) { // 当计数小于等于5时，跳出循环
                break;
            }
        }
    }

public static void main(String[] args) {
        SharedVariableSync sync = new SharedVariableSync();
        Thread threadA = new Thread(sync::threadA));
        Thread threadB = new Thread(sync::threadB));

threadA.start(); // 启动线程A
        threadB.start(); // 启动线程B

try {
            threadA.join(); // 线程A结束后，等待
            threadB.join(); // 线程B结束后，等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("最终计数: " + sync.count); // 输出最终计数结果
    }
}
```

2. **信号量同步**：
在Java中，`Semaphore`类可以实现信号量的同步机制。

下面是一个简单的信号量同步示例：

```java
import java.util.concurrent.Semaphore;

public class SemaphoreSync {
    private Semaphore semaphore = new Semaphore(1); // 创建一个容量为1的信号量

public void threadA() throws InterruptedException {
        semaphore.acquire(); // 请求资源，如果资源大于0，则获得资源
        System.out.println("线程A执行任务..."); // 执行任务
        semaphore.release(); // 释放资源
    }

public void threadB() throws InterruptedException {
        semaphore.acquire(); // 请求资源
        System.out.println("线程B执行任务..."); // 执行任务
        semaphore.release(); // 释放资源
    }

public static void main(String[] args) {
        SemaphoreSync sync = new SemaphoreSync();
        Thread threadA = new Thread(sync::threadA));
        Thread threadB = new Thread(sync::threadB));

threadA.start(); // 启动线程A
        threadB.start(); // 启动线程B

System.out.println("最终信号量状态: " + sync.semaphore getState()); // 输出最终信号量状态
    }
}
```

在上述示例中，线程A和线程B通过`Semaphore`的使用实现了同步。当`Semaphore`的计数值为0时，其他线程将无法获取资源，从而实现同步的效果。