java 设计4个线程A、B、C、D,其中A、B两个线程每次对成员变量count增加1,C、D两个线程对成员变量count每次减少1。请设计出线程安全的程序保证成员变量count的值在0~1之间波动。
时间: 2023-12-31 08:03:53 浏览: 25
可以使用Java中的Lock和Condition来实现线程同步操作。具体实现如下:
```java
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private static int count = 0;
private static Lock lock = new ReentrantLock();
private static Condition incCondition = lock.newCondition();
private static Condition decCondition = lock.newCondition();
public static void main(String[] args) {
Thread t1 = new Thread(new IncThread());
Thread t2 = new Thread(new IncThread());
Thread t3 = new Thread(new DecThread());
Thread t4 = new Thread(new DecThread());
t1.start();
t2.start();
t3.start();
t4.start();
}
static class IncThread implements Runnable {
@Override
public void run() {
while (true) {
lock.lock();
try {
// 如果count已经为1,等待减少线程对其减少操作
while (count == 1) {
incCondition.await();
}
count++;
System.out.println(Thread.currentThread().getName() + " increase count to " + count);
// 唤醒减少线程进行操作
decCondition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
static class DecThread implements Runnable {
@Override
public void run() {
while (true) {
lock.lock();
try {
// 如果count已经为0,等待增加线程对其增加操作
while (count == 0) {
decCondition.await();
}
count--;
System.out.println(Thread.currentThread().getName() + " decrease count to " + count);
// 唤醒增加线程进行操作
incCondition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
}
```
在这个实现中,我们使用了一个ReentrantLock来保护共享变量count的访问,使用了两个Condition来控制增加线程和减少线程的执行。具体步骤如下:
- 当增加线程A、B想要进行操作时,首先获取锁,判断count的值是否为1,如果是,则等待减少线程对其进行减少操作,同时释放锁并进入等待状态。
- 当减少线程C、D想要进行操作时,首先获取锁,判断count的值是否为0,如果是,则等待增加线程对其进行增加操作,同时释放锁并进入等待状态。
- 当减少线程C、D对count进行减少操作后,唤醒等待的增加线程A、B进行增加操作,同时释放锁。
- 当增加线程A、B对count进行增加操作后,唤醒等待的减少线程C、D进行减少操作,同时释放锁。
通过这样的设计,可以保证count的值在0~1之间波动。