超出最大许可数：信号量

Question

public class semaphoreTest {

static LinkedList<Integer> integerLinkedList = new LinkedList<>();
static Semaphore semaphore = new Semaphore(1);
static Object lock = new Object();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                produce();
            } catch (InterruptedException e) {
            }
        }
    });

    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                consume();
            } catch (InterruptedException e) {
            }
        }
    });

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

    t1.join();
    t2.join();

}


private static void produce() throws InterruptedException {
    semaphore.acquire();
    int value = 0;
    while (true) {
        while (integerLinkedList.size() == 10) {
            semaphore.release();
        }

        integerLinkedList.add(value++);


    }

}

private static void consume() throws InterruptedException {
    semaphore.acquire();
    while (true) {
        while (integerLinkedList.size() == 0) {
            semaphore.release();
        }
        //semaphore.release();
        Integer value = integerLinkedList.removeFirst();
        System.out.println("Size of the List is " + integerLinkedList.size() + " and value removed is " + value);
        semaphore.release();

        Thread.sleep(100);
    }
}


}

这是我尝试使用信号量作为锁来编写的生产者消费者问题。但是在几乎删除了大约 240 个元素之后我无法弄清楚它给出了一条错误消息 Maximum permit count exceeded.

我在正确的地方释放了锁，但无法弄清楚它的获取部分有什么问题。

报错信息如下：

Exception in thread "Thread-0" java.lang.Error: Maximum permit count exceeded
at java.util.concurrent.Semaphore$Sync.tryReleaseShared(Semaphore.java:192)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.releaseShared(AbstractQueuedSynchronizer.java:1341)
at java.util.concurrent.Semaphore.release(Semaphore.java:426)
at interviewQuestions.semaphoreTest.procude(semaphoreTest.java:53)
at interviewQuestions.semaphoreTest.access[=11=]0(semaphoreTest.java:12)
at interviewQuestions.semaphoreTest.run(semaphoreTest.java:23)
at java.lang.Thread.run(Thread.java:745)
Exception in thread "Thread-1" java.lang.Error: Maximum permit count exceeded
at java.util.concurrent.Semaphore$Sync.tryReleaseShared(Semaphore.java:192)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.releaseShared(AbstractQueuedSynchronizer.java:1341)
at java.util.concurrent.Semaphore.release(Semaphore.java:426)
at interviewQuestions.semaphoreTest.consume(semaphoreTest.java:72)
at interviewQuestions.semaphoreTest.access0(semaphoreTest.java:12)
at interviewQuestions.semaphoreTest.run(semaphoreTest.java:33)
at java.lang.Thread.run(Thread.java:745)

Answer 1

问题是你释放信号量的次数比获取信号量的次数多。您应该删除 while 以释放您的信号量。您应该只发布一次，因此请改用 if。

而且根据你的程序produce()和consume()应该变成这样。

生产()

private static void produce() throws InterruptedException {       
    int value = 0;      

    while (true) {
        //try to get control & put an item.
        semaphore.acquire();

        //but if the queue is full, give up and try again.
        if (integerLinkedList.size() == 10) {
            semaphore.release();
            continue;
        }

        //if not full, put an item & release the control.
        integerLinkedList.add(value++);
        semaphore.release();

    }

}

消费()

private static void consume() throws InterruptedException {        
    while (true) {
        //try to get the control and consume an item.
        semaphore.acquire();

        //but if the queue is empty, give up and try again.
        if (integerLinkedList.size() == 0) {
            semaphore.release();
            continue;
        }

        //if not empty, *consume first one, *print it, *release the control and go sleep.
        Integer value = integerLinkedList.removeFirst();
        System.out.println("Size of the List is " + integerLinkedList.size() + " and value removed is " + value);

        semaphore.release();    
        Thread.sleep(100);
    }
}

如果你希望更安全，你可以在每个 break; 语句之前放一些像 Thread.sleep(50); 这样的东西，这样你就可以给另一个线程一些时间来继续它的执行。

我假设您编写的是典型的生产者消费者问题。如果你想让我改变什么，请告诉我。无论如何希望这可以解决您的基本问题。 :))

Answer 2

虽然@Supun 的回答是正确的，但我需要线程无限期地运行。因此我找到了解决方案。

public void produces() throws InterruptedException {

    int value = 0;
    while (true){
        semaphore.acquire();
        if(integerList.size() != 10 ) {
            integerList.add(value++);
        }
        semaphore.release();
    }

}

public void consumes() throws InterruptedException {
    Thread.sleep(100);
    semaphore.acquire();
    while (true){
        Integer take = integerList.removeFirst();
        System.out.println("Size of the BlockingQueue is : "+ integerList.size()+" and the value consumed is :"+take);
        Thread.sleep(100);
        semaphore.release();
    }
}

超出最大许可数：信号量

Maximum permit count exceeded : Semaphore

java

multithreading

semaphore