import java.io.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

public class ArrayBlockingQueueSerializationBug {
    public static void main(String... args)
            throws Exception {
        final BlockingQueue<Integer> queue =
                // new LinkedBlockingQueue<Integer>();
                new ArrayBlockingQueue<Integer>(10);
        for (int i = 0; i < 5; i++) queue.add(42);

        final AtomicBoolean modifying = new AtomicBoolean(true);
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (modifying.get()) {
                    queue.poll();
                    queue.add(42);
                }
            }
        });
        thread.start();

        Collection<ByteArrayOutputStream> outs = new ArrayList<ByteArrayOutputStream>();
        for (int i = 0; i < 10000; i++) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(queue);
            oos.close();
            outs.add(baos);
        }
        modifying.set(false);

        for (ByteArrayOutputStream out : outs) {
            ObjectInputStream ois = new ObjectInputStream(
                    new ByteArrayInputStream(out.toByteArray()));
            try {
                BlockingQueue<Integer> read = (BlockingQueue<Integer>) ois.readObject();
                System.out.println("read = " + read);
                check(read);
            } catch (IOException e) {
                System.out.println(e);
            }
            ois.close();
        }
    }

    private static void check(BlockingQueue<Integer> read) {
        if (read.toString().contains("null")) {
            System.out.println("read.size() = " + read.size());
            int count = 0;
            for (Integer i : read) {
                count++;
            }
            System.out.println("count = " + count);

            throw new AssertionError();
        }
    }
}