LinkedBlockingQueue_demo

package com.thread.perfect;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class ToastOMatic
{
    public static void main(String[] args)
        throws InterruptedException
    {
        ToastQueue dryQueue = new ToastQueue(), butterQueue = new ToastQueue(), finishQueue = new ToastQueue();

        ExecutorService exec = Executors.newCachedThreadPool();

        exec.execute(new Toaster(dryQueue));
        exec.execute(new Butter(dryQueue, butterQueue));
        exec.execute(new Jammer(butterQueue, finishQueue));
        exec.execute(new Eater(finishQueue));

        TimeUnit.MILLISECONDS.sleep(1000);
        exec.shutdownNow();
    }
}

/**
 * bean
 */
class Toast
{
    public enum Status
    {
        DRY, BUTTERED, JAMMED
    }

    private Status status = Status.DRY;

    private final int id;

    public Toast(int idn)
    {
        id = idn;
    }

    public void butter()
    {
        status = Status.BUTTERED;
    }

    public void jam()
    {
        status = Status.JAMMED;
    }

    public Status getStatus()
    {
        return status;
    }

    public int getId()
    {
        return id;
    }

    @Override
    public String toString()
    {
        return "Toast [status=" + status + ", id=" + id + "]";
    }

}

/*
 * 不定长阻塞队列
 */
class ToastQueue extends LinkedBlockingQueue<Toast>
{
    private static final long serialVersionUID = 1L;
}

/**
 * 
 */
class Toaster implements Runnable
{
    private ToastQueue toastQueue;

    private int count = 0;

    private Random random = new Random(47);

    public Toaster(ToastQueue tq)
    {
        toastQueue = tq;
    }

    @Override
    public void run()
    {
        try
        {
            while (!Thread.interrupted())
            {
                TimeUnit.MILLISECONDS.sleep(100 + random.nextInt(500));
                // make Toast
                Toast t = new Toast(count++);
                System.out.println(t);
                // insert into queue
                toastQueue.add(t);
            }
        }
        catch (InterruptedException e)
        {
            System.out.println("Toaster interrupted ");
        }
        System.out.println("Toaster off ");
    }
}

// Apply butter to toast
class Butter implements Runnable
{
    private ToastQueue dryQueue, butterQueue;

    public Butter(ToastQueue dry, ToastQueue butter)
    {
        dryQueue = dry;
        butterQueue = butter;
    }

    @Override
    public void run()
    {
        try
        {
            while (!Thread.interrupted())
            {
                // Blocks until next piece of toast is available
                Toast t = dryQueue.take();
                t.butter();
                System.out.println(t);
                butterQueue.put(t);
            }
        }
        catch (InterruptedException e)
        {
            System.out.println("Butter interrupted ");
        }
        System.out.println("Butter off ");
    }
}

// apply jam to butter toast
class Jammer implements Runnable
{
    private ToastQueue butterQueue, finishedQueue;

    public Jammer(ToastQueue bq, ToastQueue fq)
    {
        butterQueue = bq;
        finishedQueue = fq;
    }

    @Override
    public void run()
    {
        try
        {
            while (!Thread.interrupted())
            {
                // Blocks until next piece of toast is available
                Toast t = butterQueue.take();
                t.jam();
                System.out.println(t);
                finishedQueue.put(t);
            }
        }
        catch (InterruptedException e)
        {
            System.out.println("Jammer interrupted ");
        }
        System.out.println("Jammer off ");

    }

}

// Consume the toast:
class Eater implements Runnable
{
    private ToastQueue finishedQueue;

    private int counter = 0;

    public Eater(ToastQueue fq)
    {
        finishedQueue = fq;
    }

    @Override
    public void run()
    {

        try
        {
            while (!Thread.interrupted())
            {
                // Blocks until next piece of toast is available
                Toast t = finishedQueue.take();
                // Verify that the toast is comming in order,and that all pieces are getting jammed:
                if (t.getId() != counter++ || t.getStatus() != Toast.Status.JAMMED)
                {
                    System.out.println(">>>ERROR : " + t);
                    System.exit(0);
                }
                else
                {
                    System.out.println("OK---> : " + t);
                }
            }
        }
        catch (InterruptedException e)
        {
            System.out.println("Eater interrupted ");
        }
        System.out.println("Eater off ");

    }

}