RWTPCValQueue<Type>

Threads Module Reference Guide
Rogue Wave web site: Home Page | Main Documentation Page

RWTPCValQueue<Type>

Module: Threads Package: Interthread Communication


RWTPCValQueue<Type>   RWTPCValBufferBase<Type>

Local Index
Header File
Description
Example
Public Constructor
Public Destructor
See Also

Local Index

Members

RWTPCValQueue()

~RWTPCValQueue()

Header File

#include <rw/itc/RWTPCValQueue.h>

Description

RWTPCValQueue<Type> is a first-in-first-out (FIFO) queue that provides producer-consumer synchronization semantics for exchanging values between cooperating threads.

In the producer-consumer synchronization model, reader threads (consumers) are blocked while the queue is empty, and writer threads (producers) are blocked while the queue is full. A queue is considered full when the number of unread entries equals or exceeds some user-specified maximum capacity.

Example

// This program uses reader and writer threads to
// copy text from standard input to standard output
// via a producer-consumer queue:

#include <iostream.h>
#include <rw/itc/RWTPCValQueue.h>
#include <rw/thread/RWThread.h>
#include <rw/thread/rwtMakeThreadFunction.h>

// A producer-consumer queue with buffer size of 10:
RWTPCValQueue<char>  pcQueue(10);

void readerThread() {
  // Read chars from queue and send to stdout. Quit when
  // sentinel NULL char is received:
  char c;
  while ((c = pcQueue.read()) != '\0')
    cout << c << flush;
}
     
void writerThread() {
  // Get chars from stdin and write to queue.  Send the NULL
  // char and quit when stream error or EOF occurs:
  char c;
  do {
    cin.get(c);
    pcQueue.write(cin.good() ? c : '\0');
  } while (cin.good());
}

int main()
{
  RWThread reader = rwtMakeThreadFunctionG(void, readerThread);
  RWThread writer = rwtMakeThreadFunctionG(void, writerThread);
  reader.start();
  writer.start();
  reader.join();
  writer.join();
  return 0;
}

Public Constructor

RWTPCValQueue(size_t maxCapacity=0, bool isOpen=true);

Constructs a value-based producer-consumer queue instance.

The parameter maxCapacity specifies the maximum number of unread entries to allow to accumulate within the queue. Once the number of entries in the queue equals this number, any thread attempting to write an additional entry is blocked until an entry is removed by a read operation, or until the capacity is increased. A capacity of zero, the default, is used to indicate that the queue has no size limit other than that imposed by memory limitations, and that all write operations should complete without blocking.

The parameter isOpen is a bool value that specifies whether the queue should be initialized in the open state, true, which is the default, or the closed state, false.

Public Destructor

~RWTPCValQueue();

Destructor.