boundedqueue.java

jxme的一些相关程序,主要是手机上程序开发以及手机和计算机通信的一些程序资料,程序编译需要Ant支持

/*

 * Copyright (c) 2001 Sun Microsystems, Inc. All rights

 * reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 *  modification, are permitted provided that the following conditions

 * are met:

 *

 * 1. Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright

 * notice, this list of conditions and the following disclaimer in

 * the documentation and/or other materials provided with the

 * distribution.

 *

 * 3. The end-user documentation included with the redistribution,

 * if any, must include the following acknowledgment:

 * "This product includes software developed by the

 * Sun Microsystems, Inc. for Project JXTA."

 * Alternately, this acknowledgment may appear in the software itself,

 * if and wherever such third-party acknowledgments normally appear.

 *

 * 4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA"

 * must not be used to endorse or promote products derived from this

 * software without prior written permission. For written

 * permission, please contact Project JXTA at http://www.jxta.org.

 *

 * 5. Products derived from this software may not be called "JXTA",

 * nor may "JXTA" appear in their name, without prior written

 * permission of Sun.

 *

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED

 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR

 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *====================================================================

 *

 * This software consists of voluntary contributions made by many

 * individuals on behalf of Project JXTA. For more

 * information on Project JXTA, please see

 * <http://www.jxta.org/>.

 *

 * This license is based on the BSD license adopted by the Apache Foundation.

 *

 * $Id: BoundedQueue.java,v 1.2 2002/03/04 21:43:01 echtcherbina Exp $

 */



package net.jxta.impl.util;



//PDA requirements 19.02.2002
//java.util.LinkedList -> java.util.Vector
//import java.util.LinkedList;
import java.util.Vector;
//PDA requirements 19.02.2002



import org.apache.log4j.Category; import org.apache.log4j.Priority;





/** A thread-safe bounded queue. The queue supports a max size, but the

    default is for the queue to be unbounded. When trying to enqueue when

    the queue is at its max size, the enqueue operation optionally blocks for

    a specified amount of time.  The dequeue operation allows non-blocking,

    blocking forever, and blocking with a timeout value.

**/

public class BoundedQueue {



    private static final Category LOG =

	Category.getInstance(BoundedQueue.class.getName());



    /** The internal queue **/

    //PDA requirements 19.02.2002
    //java.util.LinkedList -> java.util.Vector
    //private LinkedList list = new LinkedList();
    private Vector list = new Vector();
    //PDA requirements 19.02.2002



    /** The max size of the queue **/

    private int maxSize=DEFAULT_MAX_SIZE;



    /** The default max size of the queue **/

    private static final int DEFAULT_MAX_SIZE=-1;



    /** Specifies that enqueue and dequeue operations should wait forever **/

    public static final int BLOCK_FOREVER=0;



    /** Specifies that enqueue and dequeue operations should fail, not wait **/

    public static final int DO_NOT_BLOCK=-1;



    /** Specifies that enqueue operations should push the older message out **/

    public static final int DROP_OLDEST=-2;



    /** Default constructor. Creates an unbounded queue. **/

    public BoundedQueue() {

    }



    /** Creates a queue with a maximum size **/

    public BoundedQueue(int maxSize) {

	this.maxSize = maxSize;

    }



    /** Clears the queue and notifies everyone **/

    public synchronized void clear() {

        //PDA requirements 19.02.2002
        //java.util.LinkedList.clear() -> java.util.Vector.removeAllElements()
        //list.clear();
        list.removeAllElements();
        //PDA requirements 19.02.2002

        notifyAll();

    }





    /** Enqueues obj into the queue.

	<p>

	This operation is thread-safe.



        @param obj  The object to be enqueued.

	@param waitTimeout  Applicable only if the queue is bounded by a max

	  size. If the queue is full, this is the amount of time

	  the method will wait for the queue to have room. If waitTimeout is

	  BLOCK_FOREVER, enqueue will block indefinitely until the queue has

	  room or the thread is interrupted, in which case false is returned

	  straightway. If the value is DO_NOT_BLOCK, obj is not enqueued and

	  false is returned. If the value is DROP_OLDEST, the oldest message is

          dropped off the queue.

        @return Returns true if the item was enqeued. Returns false otherwise.

 	  False is also returned in the case that the the enqueue operation

	  blocks and the thread is interrupted while waiting.

	@throws InterruptedException Throws InterruptedException when the queue

	  is full, the method waits, and is interrupted during that wait.

    **/

    public synchronized boolean enqueue(Object obj, long waitTimeout)

	throws InterruptedException {

        if (maxSize != -1) {

            if (list.size() >= maxSize) {

                if (waitTimeout == DO_NOT_BLOCK) {

                    return false;

                }

                if (waitTimeout == DROP_OLDEST) {

                    //PDA requirements 19.02.2002
                    //java.util.LinkedList.removeLast() -> java.util.Vector.removeElementAt(size()-1)
                    //list.removeLast();
                    list.removeElementAt(list.size()-1);

                    //java.util.LinkedList.addLast(Object obj) -> java.util.Vector.addElement(Object obj)
                    //list.addLast(obj);
                    list.addElement(obj);
                    //PDA requirements 19.02.2002

                    notifyAll();

                    return true;

                }

            }



            // we must wait until the queue is nolonger full or the deadline

            // is passed. We can be awakened in the middle without necessarily

            // succeeding. (queue shortened and then lengthened before we

            // got a share of the cpu).

            if (waitTimeout == BLOCK_FOREVER) {

                while (list.size() >= maxSize) wait();

            } else {

                long deadLine = System.currentTimeMillis() + waitTimeout;

                while (list.size() >= maxSize) {

                    long timeLeft = deadLine - System.currentTimeMillis();

                    if (timeLeft < 0) return false; // too late, then.

                    wait(timeLeft);

                }

            }

	}

        //PDA requirements 19.02.2002
        //java.util.LinkedList.addLast(Object obj) -> java.util.Vector.addElement(Object obj)
        //list.addLast(obj);
        list.addElement(obj);
        //PDA requirements 19.02.2002

        notifyAll();

        return true;

    }



    /** Enqueues obj into the queue. If the queue has a max size and the queue

	is at the max size when enqueue is called, this method will block until

	there is room in the queue, or the thread is interrupted while

	waiting for the queue to have room.

	<p>

	This operation is thread-safe.



        @param obj  The object to be enqueued.

        @return Returns true if the item was enqeued. Returns false otherwise.

 	  False is also returned in the case that the the enqueue operation

	  blocks and the thread is interrupted while waiting.

	@throws InterruptedException Throws InterruptedException when the queue

	  is full, the method waits, and is interrupted during that wait.

    **/

    public boolean enqueue(Object obj) throws InterruptedException {

	return enqueue(obj, BLOCK_FOREVER);

    }





    /** Dequeues an object. If the queue is empty, it will wait for waitTimeout

	time before returning.

	@param waitTimeout  The time to wait for the queue to have something

          to become non-empty in the case that it is empty. A value of

	  BLOCK_FOREVER specifies 'wait forever', while a value of DO_NOT_BLOCK

	  specifies to return immediately even if there is nothing to dequeue.

	@throws InterruptedException Throws InterruptedException when the queue

	  is empty and the method is blocked waiting for a new message and

	  the thread is interrupted during that time.

    **/

    public synchronized Object dequeue(long waitTimeout)

        throws InterruptedException {



        if (waitTimeout == DO_NOT_BLOCK && list.isEmpty()) {

            return null;

        }



        if (waitTimeout == BLOCK_FOREVER) {

            while  (list.isEmpty()) wait();

        } else {

            long deadLine = System.currentTimeMillis() + waitTimeout;

            while  (list.isEmpty()) {

                long timeLeft = deadLine - System.currentTimeMillis();

                if (timeLeft < 0) return null;

                wait(timeLeft);

            }

        }



        // Minimize the time we keep the lock after notifying; that makes for

        // smoother scheduling. Thus go dequeue the thing before we notify.

        //PDA requirements 19.02.2002
        //java.util.LinkedList.removeFirst() -> java.util.Vector.removeElementAt(int index)
        //Object retval = list.removeFirst();
        Object retval = list.elementAt(0);
        list.removeElementAt(0);
        //PDA requirements 19.02.2002



        notifyAll();

        return retval;

    }

}