我必须使用 Java 信号量来解决这个问题，但我不知道如何解决，也找不到任何相关的 Java 资料。事情是这样的:

线程有多种:男性和女性。两者都想使用数量为 BATHROOM_SIZE 的相同资源。 5条规则:

1. 每个线程在发出需要使用资源的信号后，应该等待直到他能够使用它。
2. 防止超过 BATHOOM_SIZE 个线程同时使用资源的情况。
3. 防止男女同时上厕所。
4. 线程应该同时使用资源。如果一种类型有多个线程，最多 BATHROOM_SIZE 个线程应该使用资源。
5. 防止饥饿。

结果

适用于:

1 名女性，1 名男性，5 名女性，5 名男性

失败原因:

5 女 1 男、5 男 1 女、2 男 2 女、5 男 5 女。

从星期一开始我就一直在努力让它发挥作用，现在我已经没有想法了。

代码

所以我的任务是编写实现 BathroomInterface 的 Bathroom.java 类:

public interface BathroomInterface {

    public static final int BATHROOM_SIZE = 3; //3 is just example
    void manEnter();
    void manExit();
    void womanEnter();
    void womanExit();
}

在系统中有许多男线程和女线程，它们的工作方式如下:

for(int i = 0; i < n; i++) {
  bathroom.manEnter();
  //uses bathroom random amount of time
  bathroom.manExit();
}

for(int i = 0; i < m; i++) {
  bathroom.womanEnter();
  //uses bathroom random amount of time
  bathroom.womanExit();
}

我也有 Bathroom.java 类的方案，我必须扩展:

import java.util.concurrent.Semaphore;

public class Bathroom implements BathroomInterface {

    
    private Semaphore mutex = new Semaphore(1, true);

    public void womanEnter() {
        mutex.acquireUninterruptibly();
    }

    public void womanExit() {
        mutex.release();
    }

    public void manEnter() {
        mutex.acquireUninterruptibly();        
    }

    public void manExit() {
        mutex.release();
    }
}

这是我目前所做的:

import java.util.concurrent.Semaphore;

public class Bathroom implements BathroomInterface {
    int manW=0, manU=0, womanW=0, womanU=0; //*U-using, *W-waiting
    private Semaphore mutex = new Semaphore(1, false);

    public void womanEnter() {
        womanW++;
        StateChange();
    }

    public void womanExit() {
        womanU--;
        mutex.release();
        StateChange();
    }

    public void manEnter(){
        manW++;
        StateChange();
    }

    public void manExit() {
        manU--;
        mutex.release();
        StateChange();
    }
    
    void StateChange() {
        if(womanU==0 && manU==0) {
            if(manW>womanW) {
                while(manW>0 && manU<BATHROOM_SIZE) {
                    manW--;
                    manU++;
                    mutex.acquireUninterruptibly();
                }
            }
            else {
                while(womanW>0 && womanU<BATHROOM_SIZE) {
                    womanW--;
                    womanU++;
                    mutex.acquireUninterruptibly();
                }
            }
        }
        if(womanU==0 && manU<BATHROOM_SIZE) {
            while(manW>0 && manU<BATHROOM_SIZE) {
                manW--;
                manU++;
                mutex.acquireUninterruptibly();
            }
        }
        if(manU==0 && womanU<BATHROOM_SIZE) {
            while(womanW>0 && womanU<BATHROOM_SIZE) {
                womanW--;
                womanU++;
                mutex.acquireUninterruptibly();
            }
        }
    }
}

最佳答案

实际上这个练习是使用监视器而不是信号量完成的。你所做的大部分都很好，你缺少条件。所以，在你的浴室课上，声明:

一把锁:

private Lock lock = new ReentrantLock();

2 个条件或队列，附加到您的锁:

private Condition womenWaitingQueue = lock.newCondition();
private Condition menWaitingQueue = lock.newCondition();

2 个计数器知道有多少人在等待，2 个计数器知道有多少人正在使用:

private int womenWaitingN = 0;
private int menWaitingN = 0;
private int womenUsingN = 0;
private int menUsingN = 0;

当然还有资源的数量:

private final int BATHROOM_CAPACITY = 5;
private int free_resources = BATHROOM_CAPACITY;

所有 4 个函数都在这里，但由于家庭作业标签而被删除

这里重要的是防止饥饿，如果有女性在等，则不允许任何男性进入洗手间，反之亦然。

所以，条件是如果一个男人想进入浴室，它必须检查浴室是否至少有 1 个空闲位置(使用免费资源)以及浴室中是否有女性(使用 womenUsingN)。如果不满足这两个条件中的任何一个，则该人必须等待(使用 menWaitingQueue):

menWaitingQueue.await();

当一个男人离开洗手间时，它必须检查是否有女人在等待(womenWaitingN)，如果有，他们会得到通知:

womanWaitingQueue.signal();

由于有 menUsingN 计数器，收到此信号的女性将无法进入，直到浴室里没有男性为止。如果没有女性在等，则可以示意男性进入洗手间。这可以防止饥饿，因为优先考虑异性(如果等待)。

最后，每个函数都必须在每个进入/退出函数的开始/结束时锁定/解锁锁。

lock.lock();
lock.unlock();

我认为有了这些新信息，您将能够自己制作这些功能。祝你好运!

关于 java 男女通用浴室，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11135207/