自定义队列实现

package async;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * 自定义队列
 *
 * @version 2013-9-9
 */
public class Queue<T>
{
    /**
     * 默认队列容量
     */
    private static final int DEFAULT_SIZE = 100;

    /**
     * 队列容量
     */
    private int size;

    /**
     * 队列数据
     */
    private List<T> data = new ArrayList<T>();

    /**
     * 读取锁
     */
    private Object lock = new Object();

    /**
     *
     * 构造函数
     */
    public Queue()
    {
        this.size = DEFAULT_SIZE;
    }

    /**
     *
     * 构造函数
     *
     * @param size
     *            队列容量
     */
    public Queue(int size)
    {
        this.size = size;
    }

    /**
     *
     * 添加任务
     *
     * @param t
     *            任务对象
     * @param isWait
     *            队列满是否等待
     * @return 是否添加成功
     */
    public boolean put(T t, boolean isWait)
    {
        synchronized (lock)
        {
            if (isFull())
            {
                if (isWait)
                {
                    try
                    {
                        lock.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                        return false;
                    }
                }
                else
                {
                    System.out.println("The queue is full;");
                    return false;
                }
            }
            data.add(t);
            lock.notifyAll();
            return true;
        }
    }

    /**
     *
     * 获取任务
     *
     * @param isWait
     *            队列空是否等待
     * @return 任务对象
     */
    public T get(boolean isWait)
    {
        synchronized (lock)
        {
            if (isEmpty())
            {
                if (isWait)
                {
                    try
                    {
                        lock.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                        return null;
                    }
                }
                else
                {
                    System.out.println("The queue is empty;");
                    return null;
                }
            }
            T task = data.remove(0);
            lock.notifyAll();
            return task;
        }
    }

    /**
     *
     * 队列是否为空
     *
     * @return 队列是否为空
     */
    public synchronized boolean isEmpty()
    {
        return 0 == data.size();
    }

    /**
     *
     * 队列是否已满
     *
     * @author Jinglong Wu
     * @return 队列是否已满
     */
    public synchronized boolean isFull()
    {
        return this.size == data.size();
    }
}