Question

我正在测试信号量与典型的生产者－消费者问题的使用，其中我只有一个生产者和一个消费者。生产者一次添加一种产品，而消费者可以同时撤消几种产品。

要执行测试，生产者和消费者存储并从10个元素的数组中删除数字，其中0表示没有产品，其他任何数字表示产品。存储和检索项目的访问权限集中在一个名为Data的类中。如果有多个线程同时工作，我会使用互斥锁有序地使用向量。

在执行它时，根据线程执行的操作，我发现权限数量不正确。该应用程序显示错误，因为生产者的信号量表明它具有权限，但是数据向量已满。

package producer.consumer;

import java.io.IOException;

public class ProducerConsumer {

    public static void main(String[] args) throws IOException {
        final int MAX = 10;

        Data data = new Data(MAX);
        Consumer consumer = new Consumer(data);
        Producer producer = new Producer(data);

        consumer.start();
        producer.start();
    }   
}

package producer.consumer;

public class Producer extends Thread{
    private final Data data;

    public Producer(Data data) {
         this.data = data;
    }

    @Override
    public void run() {
        while (true) {
            try {
                data.add((int) (Math.random() * data.getLength()) + 1);
            } catch (InterruptedException ex) {
                System.out.println(ex.getMessage());
            }
        }
    }  
}

package producer.consumer;

import java.util.logging.Level;
import java.util.logging.Logger;

public class Consumer extends Thread{
    private final Data data;

    public Consumer(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        while (true) {
            try {
                data.remove((int) (Math.random() * data.getLength()) + 1);
            } catch (InterruptedException ex) {
               Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

package producer.consumer;

import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.Semaphore;

public class Data {
    private final int[] data;
    private final Semaphore mutex = new Semaphore(1);
    private final Semaphore semProducer, semConsumer;

    public Data(int MAX) throws IOException {
        data = new int[MAX];
        semProducer = new Semaphore(MAX);
        semConsumer = new Semaphore(0);
    }

    public int getLength() {
        return data.length;
    }

    public void add(int number) throws InterruptedException {

        semProducer.acquire();

        mutex.acquire();
        System.out.println("trying to add a product");

        int i = 0;
        while (data[i] != 0) {
            i++;
        }
        data[i] = number;

        int permits = semConsumer.availablePermits() + 1;

        System.out.println("data added in " + i + " " + Arrays.toString(data)
            + " Resources consumer " + permits
            + " Resources producer  " + semProducer.availablePermits());
        mutex.release();

        semConsumer.release();
    }

    public void remove(int numberElements) throws InterruptedException {

        semConsumer.acquire(numberElements);

        mutex.acquire();
        System.out.println("trying to withdraw " + numberElements);

        for (int i = 0; i < numberElements; i++) {
            if (data[i] != 0) {
                data[i] = 0;
            }
        }

        int permisos = semProducer.availablePermits() + 1;
        System.out.println(" Retired " + numberElements + " " + Arrays.toString(data)
            + " Resources consumer " + semConsumer.availablePermits()
            + " Resources producer " + permisos);
        mutex.release();

        semProducer.release(numberElements);
    }
}

非常感谢您的帮助。

Answer 1

您的消费者并不总是消费其声称要消费的东西。

    for (int i = 0; i < numberElements; i++) {
        if (data[i] != 0) {
            data[i] = 0;
        }
    }

假设numberElements为3，并且在data [7]，data [8]，data [9]中恰好有3个可用元素。

循环以i == 3终止，没有任何内容被删除，但是生产者信号灯仍将被“ upup”3。

在使用者中，如果将i用作数组索引，则它需要覆盖整个数组，并且需要一个单独的计数器来表示“元素已删除”。

即使生产者将最先填充的那些元素也不是可用的元素将始终位于编号最小的数据时隙中的情况。考虑生产者设法生产至少5个元素的时间序列，然后消费者运行消耗2，然后立即再次运行消耗3，然后再生产更多元素。在使用者的第二次运行中data [0]和data [1]将为空，我们遇到了我描述的场景。

Answer 2

编辑：获得和发放许可似乎是正确的；但是，您需要确保使用者实际上会清除正确数量的元素。

例如，使用{p>编辑Data类

public void remove(int numberElements) throws InterruptedException {
    semConsumer.acquire(numberElements);
    mutex.acquire();
    System.out.println("remove: num-elem=" + numberElements);

    int consumed=0;
    for (int i = 0; consumed<numberElements; i++) {
        if (data[i] != 0) {
            data[i] = 0;
            consumed++;
        }
    }
    System.out.println(
            " Retired " + numberElements + " " + Arrays.toString(data)  );
    mutex.release();
    semProducer.release(numberElements);
}

还要注意，这种实现方式效率不是很高（插入和删除项目时都需要遍历整个数组，当MAX很大时，这可能会很昂贵。）

Java中的信号量。生产者－消费者问题

2 个答案: