LinkedBlockingQueue.h

Go to the documentation of this file.

#ifndef _RMS_LINKEDBLOCKINGQUEUE_H
#define _RMS_LINKEDBLOCKINGQUEUE_H

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/xtime.hpp>

#include <queue>

namespace gov {

namespace fnal {

namespace cd {

namespace rms {

namespace util {

/**
 * This is a templated thread safe container that is meant to
 * emulate the LinkedBlockingQueue that is used in the Java 
 * version of RMS.
 *
 * @author Kurt Biery
 * @author Steve Foulkes
 * @version $Revision: 1.2.14.1 $ $Date: 2019/09/27 00:07:32 $
 */

template <class QueueType> class LinkedBlockingQueue {
 public:
    /**
     * Add an element to the queue.  After obtaining the queue lock,
     * push an object onto the stack and notify the condition variable
     * that the queue is not empty.
     *
     * @param object The object that is to be inserted into the queue.
     */
    void add(QueueType object) {
        boost::mutex::scoped_lock lk(_queueLock);
        
        _queue.push(object);
        _queueCondition.notify_one();
        
        return;
    }

    /**
     * Take an element off the queue.  If the queue is empty,
     * this will block until an element is added to the queue.
     *
     * @return An object from the queue.
     */
    QueueType take() {
        QueueType queueEntry;
        
        boost::mutex::scoped_lock lk(_queueLock);
        
        while (_queue.size() == 0) {
            _queueCondition.wait(lk);
        }

        queueEntry = _queue.front();
        _queue.pop();

        return queueEntry;
    }

    /**
     * Take an element off the queue.  If the queue is empty,
     * this will wait at most timeout seconds before returning.
     *
     * @param timeout The amount of time to wait, in seconds, 
     * before returning if the queue is empty.
     *
     * @return An object from the queue if one be can retrieved
     * before the timeout.  An object created with its befault
     * constructor will be returned otherwise.
     */
    QueueType poll(long timeout) {
        QueueType queueEntry;
        
        boost::xtime xt;

#if BOOST_VERSION >= 105000
        boost::xtime_get(&xt, boost::TIME_UTC_);
#else
        boost::xtime_get(&xt, boost::TIME_UTC);
#endif

        xt.sec += timeout;

        boost::mutex::scoped_lock lk(_queueLock);

        while (_queue.size() == 0) {
            if (!_queueCondition.timed_wait(lk, xt)) {
                return queueEntry;
            }
        }

        queueEntry = _queue.front();
        _queue.pop();
        
        return queueEntry;
    }

    /**
     * Take an element off the queue.  This function will not
     * block if the queue is empty.
     *
     * @return An object from the queue if the queue is not
     * empty.  An object created with its befault constructor 
     * will be returned otherwise.
     */
    QueueType poll() {
        QueueType queueEntry;
        boost::mutex::scoped_lock lk(_queueLock);

        while (_queue.size() == 0) {
            return queueEntry;
        }

        queueEntry = _queue.front();
        _queue.pop();

        return queueEntry;
    }

 private:    
    /**
     * Mutex for protecting the queue.  A process can only read or write 
     * to the queue if it holds this lock. 
     */
    boost::mutex _queueLock;

    /** Condition variabled that allows the queue to block a process if the 
     * queue is empty. 
     */
    boost::condition _queueCondition; 
    
    /**
     * An STL queue is used as the actual data container. 
     */
    std::queue<QueueType> _queue;     

};

}  // end of namespace util

}  // end of namespace rms

}  // end of namespace cd

}  // end of namespace fnal

}  // end of namespace gov

#endif