防止两线程程序中的死锁

Question

Suppose I have the following code, where one thread generates squares and writes them to a buffer while another thread prints them:

import java.util.*;

public class Something {

public static Buffer buffer = new Buffer();

public static class Buffer {

    private int[] buffer;
    private static final int size = 10;

    //Indexes for putting and taking element form buffer
    private int in, out;

    //Number of elements in buffer
    private int k;

    public Buffer() {
        buffer = new int[size];
        in = 0;
        out = 0;
        k = 0;
    }

    public synchronized void put(int e) {
        try {
            while (k == buffer.length) {
                wait();
            }
        } catch (InterruptedException ex) {
        }
        buffer[in] = e;
        k++;
        in = ++in % size;
        notifyAll();
    }

    public synchronized int take() {
        try {
            while (k == 0) {
                wait();
            }
        } catch (InterruptedException ex) {
        }
        int e = buffer[out];
        buffer[out] = 0;
        out = ++out % size;
        k--;
        notifyAll();
        return e;
    }

    public synchronized boolean notEmpty() {
        return k != 0;
    }

}

public static class Generator implements Runnable {

    int limit;

    public Generator(int lim) {
        limit= lim;
    }

    @Override
    public void run() {
        for (int i = 1; i < limit; i++) {
            buffer.put(i * i);
        }
    }
}

public static class Printer implements Runnable {

    private Thread[] generators;

    public Printer(Thread[] gen) {
        generators = gen;
    }

    public synchronized boolean nobody() {
        for (Thread th : generators) {
            if (th.isAlive()) {
                return false;
            }
        }
        return true;
    }

    @Override
    public void run() {
        int x = 0;
        while (!nobody() || buffer.notEmpty()) {
            x = buffer.take();
            System.out.println(x);
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    Thread generator = new Thread(new Generator(69));
    Thread printer = new Thread(new Printer(new Thread[]{generator}));

    generator.start();
    printer.start();

    generator.join();
    printer.join();
}

}

Generator should generate squares of numbers until it reaches some limit ( limit = 69 , in this case). Printer should print all values generated by Generator. Buffer works somewhat like ring buffer. Indexes for putting ( in ) and taking ( out ) element are cycling in bounds of buffer size. Buffer has methods for putting and taking elements from buffer. Generator thread cannot put elements in buffer if it is full (that is, there are no zero elements; zero element is 0, for precision sake...). Printer works this way: first it checks if there are any alive generator threads and then checks if buffer contains only zero elements. If neither of these conditions is true, printer thread terminates.

Now, to the problem. I always get printed all squares from 1 to 68, which is expected output of this program. However , on very rare occasion after all numbers had been output I get a deadlock. How rarely? Well, maybe in 1 out of 100 executions of program. I had to keep hitting "F6" on NetBeans like crazy to get a deadlock. And yes, I know that I can test this simply putting all main code in for loop. Conversely , if I comment out print line in Printers' run method, deadlock happens almost all the time. Here:

        @Override
        public void run() {
        int x = 0;
        while (!nobody() || buffer.notEmpty()) {
            x = buffer.take();
            //System.out.println(x);
        }
    }

I do not expect this behavior, because element still gets taken from buffer and generator should be awoken.

Why does this happen? And how do I fix it? Sorry if question isn't clear enough, I'll try to clarify it as best I can if needed.

Answer 1

I think I fount the problem. Here is what I got: There is a very short moment in time, where the Generator thread is still alive (ie Thread.isAlive() will return true ), but the Generator has left the for -loop within run() . If the Printer queries its while -condition within its run() at this point in time, it will try to take() something, that is not there (and never will be). Indeed, you can verify, that the Generator always finishes, meaning termination detection on the side of the Printer is faulty. For a hot fix, you can simply add a magic constant is Printer s while condition:

@Override
public void run() {
    int x = 0;
    int count = 0;
    while (++count < 69) {
        x = buffer.take();
        System.out.println(x);
    }
}

For a clean termination detection, you could set some common flag-variable to false , signaling that the Generator has finished work and the Printer can stop working. But this has to be done in a synchronized manner, meaning the Printer is not allowed to query this condition, while the Generator is after its last push , but before it sets this common flag.