java - 我的代码是否处于死锁状态？

Question

在编译下面的代码时，它似乎处于死锁状态，我不知道如何修复它。我试图将管道编写为作为缓冲区链接在一起的一系列线程，每个线程都可以读取管道中的前一个节点，然后写入下一个节点。总体目标是将随机生成的数据数组列表溢出到 10 个线程并对其进行排序。

    class Buffer{
    // x is the current node
    private int x;
    private boolean item;
    private Lock lock = new ReentrantLock();
    private Condition full = lock.newCondition();
    private Condition empty = lock.newCondition();

    public Buffer(){item = false;}

    public int read(){
        lock.lock();
        try{
          while(!item)
             try{full.await();}
             catch(InterruptedException e){}
          item = false;
          empty.signal();
          return x;
     }finally{lock.unlock();}
    }

    public void write(int k){
        lock.lock();
        try{
        while(item)
           try{empty.await();}
           catch(InterruptedException e){}
        x = k; item = true;
        full.signal();
      }finally{lock.unlock();}

  }
}

class Pipeline extends Thread {

    private Buffer b;
    //private Sorted s;
    private ArrayList<Integer> pipe; // array pipeline
    private int ub; // upper bounds
    private int lb; // lower bounds

    public Pipeline(Buffer bf, ArrayList<Integer> p, int u, int l) {
        pipe = p;ub = u;lb = l;b = bf;//s = ss;
    }

    public void run() {
        while(lb < ub) {
            if(b.read() > pipe.get(lb+1)) {
                b.write(pipe.get(lb+1));
            }

            lb++;
        }

        if(lb == ub) {
            // store sorted array segment
            Collections.sort(pipe);
            new Sorted(pipe, this.lb, this.ub);
        }
    }

}

class Sorted {

    private volatile ArrayList<Integer> shared;
    private int ub;
    private int lb;

    public Sorted(ArrayList<Integer> s, int u, int l) {
        ub = u;lb = l;shared = s;
        // merge data to array from given bounds
    }
}

class Test1 {
    public static void main(String[] args) {


        int N = 1000000;
        ArrayList<Integer> list = new ArrayList<Integer>();

        for(int i=0;i<N;i++) {
            int k = (int)(Math.random()*N);
            list.add(k);
        }

        // write to buffer
        Buffer b = new Buffer();
        b.write(list.get(0));

        //Sorted s = new Sorted();

        int maxBuffer = 10;
        int index[] = new int[maxBuffer+1];
        Thread workers[] = new Pipeline[maxBuffer];

        // Distribute data evenly over threads
        for(int i=0;i<maxBuffer;i++) 
            index[i] = (i*N) / maxBuffer;

        for(int i=0;i<maxBuffer;i++) {
            // create instacen of pipeline
            workers[i] = new Pipeline(b,list,index[i],index[i+1]);
            workers[i].start();
        }

        // join threads
        try {
            for(int i=0;i<maxBuffer;i++) {
                workers[i].join();
            }
        } catch(InterruptedException e) {}

        boolean sorted = true;

        System.out.println();
        for(int i=0;i<list.size()-1;i++) {
            if(list.get(i) > list.get(i+1)) {
                sorted = false;
            }
        }

        System.out.println(sorted);
    }
}

Answer 1

当您启动 run 方法时，所有线程都将阻塞，直到第一个线程命中 full.await()。然后一个接一个，所有线程最终都会命中 full.await()。他们会等待这个信号。

但是，full.signal 发生的唯一位置是在其中一个读取方法完成之后。由于永远不会到达此代码(因为永远不会触发信号)，因此最终所有线程都会等待。

简单来说，只有1次读操作完成后，才会触发写操作。如果你反转逻辑，你开始为空，你写入缓冲区(用信号等)，然后线程尝试读取，我希望它会起作用。

一般来说，您希望在读取管道之前对其进行写入。 (或者没有什么可读的)。

我希望我没有误读您的代码，但这就是我在第一次扫描时看到的。