Question

我遇到的问题是，当生产者填充arraylist缓冲区中的所有位置时，每次程序都会停止执行。但是，从理论上讲。消费者进程仍然可以进入get（）函数，因为notEmpty信号量现在获得的信号值高达10。因此，在消费者进程将信号值释放回信号量notFull之后，生产者进程仍然可以工作。

但它停止了，我找不到问题。

以下是该计划：

import java.util.List;
import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.Semaphore;
/**
 * A bounded buffer maintains a fixed number of "slots". Items can be
 * inserted into and removed from the buffer. The buffer has a maximum
 * size.
 */

class BoundedBuffer2
{
  // the maximum size of the bounded buffer
  final public static int MAXSIZE = 10;
  Semaphore notEmpty = new Semaphore(0);
  Semaphore notFull = new Semaphore(MAXSIZE);
  Semaphore sema = new Semaphore(1);


  // the buffer
  volatile List<Integer> buffer;

  public BoundedBuffer2()
  {
    buffer = new ArrayList<Integer>();
  }

  // add an element to the end of the buffer if it is not full
  public synchronized void put(int input)
    throws InterruptedException
  {
      notFull.acquire();
      sema.acquire();
      buffer.add(input);
      sema.release();
      notEmpty.release();
  }

  // take an element from the front of the buffer
  public synchronized int get()
    throws InterruptedException
  {
      notEmpty.acquire();
      sema.acquire();
      int result = buffer.remove(0);
      sema.release();
      notFull.release();
      return result;
  }

  public int size()
  {
    int result = buffer.size();
    return result;
  }
}

/**
 * An instance of the Producer class produces new integers at random
 * intervals, and inserts them into a bounded buffer.
 */

class Producer2 extends Thread
{
  // the buffer in which to insert new integers
  BoundedBuffer2 buffer;

  public Producer2(BoundedBuffer2 buffer)
  {
    this.buffer = buffer;
  }

  public void run()
  {
    Random random = new Random();

    try {
      while (true) {
    Thread.sleep(100);
    //insert a random integer

    int next = random.nextInt();
    buffer.put(next);



    System.err.println("b.size() increases to " + buffer.size());
      }
    }
    catch (InterruptedException e) {}
  }
}

/**
 * An instance of the Consumer class consumes integers from a bounded
 * buffer at random intervals.
 */

class Consumer2 extends Thread
{
  // the buffer in which to insert new integers
  BoundedBuffer2 buffer;

  public Consumer2(BoundedBuffer2 buffer)
  {
    this.buffer = buffer;
  }

  public void run()
  {
    Random random = new Random();

    try {
      while (true) {

    Thread.sleep(200);
          //get the next integer from the buffer
    int next = buffer.get();

    System.err.println("next = " + next);
    System.err.println("b.size() reducted to " + buffer.size());


      }
    }
    catch (InterruptedException e) {}
  }
}

public class UseBuffer2
{
  public static void main(String [] args)
  {
    BoundedBuffer2 buffer = new BoundedBuffer2();
    Producer2 p = new Producer2(buffer);
    Consumer2 c = new Consumer2(buffer);

    p.start();
    c.start();
  }
}

以下是控制台的输出：

b.size() increases to 1
b.size() increases to 2
next = 400524264
b.size() reducted to 1
b.size() increases to 2
b.size() increases to 3
next = 241523118
b.size() reducted to 2
b.size() increases to 3
next = -1618289090
b.size() reducted to 2
b.size() increases to 3
b.size() increases to 4
next = -316455080
b.size() reducted to 3
b.size() increases to 4
b.size() increases to 5
next = 338682909
b.size() reducted to 4
b.size() increases to 5
b.size() increases to 6
next = -961276708
b.size() reducted to 5
b.size() increases to 6
b.size() increases to 7
next = 2056804692
b.size() reducted to 6
b.size() increases to 7
b.size() increases to 8
next = -301063524
b.size() reducted to 7
b.size() increases to 8
b.size() increases to 9
next = -148582342
b.size() reducted to 8
b.size() increases to 9
b.size() increases to 10
next = -2076430410
b.size() reducted to 9
b.size() increases to 10

Answer 1

您的put()和get()方法已同步。因此，如果生产者输入put()方法，尝试获取notFull信号量，但不能因为缓冲区已满，它会永久阻塞，保持输入同步方法时获取的锁定。因此，消费者无法进入get（）方法，也无法从缓冲区中删除元素。

Answer 2

阅读synchronized关键字的工作原理：https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html

关于Java并发程序的一个奇怪的错误（使用信号量）

2 个答案: