Message queue
In computer science, message queues and mailboxes are software-engineering components typically used for inter-process communication, or for inter-thread communication within the same process. They use a queue for messaging – the passing of control or of content. Group communication systems provide similar kinds of functionality.
The message queue paradigm is a sibling of the publisher/subscriber pattern, and is typically one part of a larger message-oriented middleware system. Most messaging systems support both the publisher/subscriber and message queue models in their API, e.g. Java Message Service.
Overview
Message queues provide an asynchronous communications protocol, meaning that the sender and receiver of the message do not need to interact with the message queue at the same time. Messages placed onto the queue are stored until the recipient retrieves them. Message queues have implicit or explicit limits on the size of data that may be transmitted in a single message and the number of messages that may remain outstanding on the queue.Many implementations of message queues function internally: within an operating system or within an application. Such queues exist for the purposes of that system only.
Other implementations allow the passing of messages between different computer systems, potentially connecting multiple applications and multiple operating systems. These message queueing systems typically provide enhanced resilience functionality to ensure that messages do not get "lost" in the event of a system failure. Examples of commercial implementations of this kind of message queueing software include IBM MQ and Oracle Advanced Queuing. There is a Java standard called Java Message Service, which has several proprietary and free software implementations.
Implementations exist as proprietary software, provided as a service, open source software, or a hardware-based solution.
Proprietary options have the longest history, and include products from the inception of message queuing, such as IBM MQ, and those tied to specific operating systems, such as Microsoft Message Queuing.
There are also cloud-based message queuing service options, such as Amazon Simple Queue Service, StormMQ, IronMQ, Solace, and IBM MQ has a cloud-based managed queuing service.
There are a number of open source choices of messaging middleware systems, including Apache ActiveMQ, Apache Kafka, Apache Qpid, Apache RocketMQ, Beanstalkd, Enduro/X, HTTPSQS, JBoss Messaging, JORAM, RabbitMQ, Sun Open Message Queue, and Tarantool.
In addition to open source systems, hardware-based messaging middleware exists with vendors like Solace, Apigee and Tervela offering queuing through silicon or silicon/software datapaths. IBM also offers its MQ software on an appliance.
Most real-time operating systems, such as VxWorks and QNX, encourage the use of message queueing as the primary inter-process or inter-thread communication mechanism. The resulting tight integration between message passing and CPU scheduling is attributed as a main reason for the usability of RTOSes for real time applications. Early examples of commercial RTOSes that encouraged a message-queue basis to inter-thread communication also include VRTX and pSOS+, both of which date to the early 1980s. The Erlang programming language uses processes to provide concurrency; these processes communicate asynchronously using message queuing.
Usage
In a typical message-queueing implementation, a system administrator installs and configures message-queueing software, and defines a named message queue. Or they register with a message queuing service.An application then registers a software routine that "listens" for messages placed onto the queue.
Second and subsequent applications may connect to the queue and transfer a message onto it.
The queue-manager software stores the messages until a receiving application connects and then calls the registered software routine. The receiving application then processes the message in an appropriate manner.
There are often numerous options as to the exact semantics of message passing, including:
- Durability - messages may be kept in memory, written to disk, or even committed to a DBMS if the need for reliability indicates a more resource-intensive solution.
- Security policies - which applications should have access to these messages?
- Message purging policies - queues or messages may have a "time to live"
- Message filtering - some systems support filtering data so that a subscriber may only see messages matching some pre-specified criteria of interest
- Delivery policies - do we need to guarantee that a message is delivered at least once, or no more than once?
- Routing policies - in a system with many queue servers, what servers should receive a message or a queue's messages?
- Batching policies - should messages be delivered immediately? Or should the system wait a bit and try to deliver many messages at once?
- Queuing criteria - when should a message be considered "enqueued"? When one queue has it? Or when it has been forwarded to at least one remote queue? Or to all queues?
- Receipt notification - A publisher may need to know when some or all subscribers have received a message.
Standards and protocols
Historically, message queuing has used proprietary, closed protocols, restricting the ability for different operating systems or programming languages to interact in a heterogeneous set of environments.An early attempt to make message queuing more ubiquitous was Sun Microsystems' JMS specification, which provided a Java-only abstraction of a client API. This allowed Java developers to switch between providers of message queuing in a fashion similar to that of developers using SQL databases. In practice, given the diversity of message queuing techniques and scenarios, this wasn't always as practical as it could be.
Three standards have emerged which are used in open source message queue implementations:
- Advanced Message Queuing Protocol – feature-rich message queue protocol, approved as ISO/IEC 19464 since April 2014
- Streaming Text Oriented Messaging Protocol – simple, text-oriented message protocol
- MQTT - lightweight message queue protocol especially for embedded devices
Some proprietary implementations also use HTTP to provide message queuing by some implementations, such as Amazon's SQS. This is because it is always possible to layer asynchronous behaviour over a synchronous protocol using request-response semantics. However, such implementations are constrained by the underlying protocol in this case and may not be able to offer the full fidelity or set of options required in message passing above.
Synchronous vs. asynchronous
Many of the more widely known communications protocols in use operate synchronously. The HTTP protocol – used in the World Wide Web and in web services – offers an obvious example where a user sends a request for a web page and then waits for a reply.However, scenarios exist in which synchronous behaviour is not appropriate. For example, AJAX can be used to asynchronously send text, JSON or XML messages to update part of a web page with more relevant information. Google uses this approach for their , a search feature which sends the user's partially typed queries to Google's servers and returns a list of possible full queries the user might be interested in the process of typing. This list is asynchronously updated as the user types.
Other asynchronous examples exist in event notification systems and publish/subscribe systems.
- An application may need to notify another that an event has occurred, but does not need to wait for a response.
- In publish/subscribe systems, an application "publishes" information for any number of clients to read.
Applications need not be exclusively synchronous or asynchronous. An interactive application may need to respond to certain parts of a request immediately, but may queue other parts to be done some time later.
In all these sorts of situations, having a subsystem which performs message-queuing can help improve the behavior of the overall system.
Implementation in UNIX
There are two common message queue implementations in UNIX. One is part of the SYS V API, the other one is part of POSIX.SYS V
UNIX SYS V implements message passing by keeping an array of linked lists as message queues. Each message queue is identified by its index in the array, and has a unique descriptor. A given index can have multiple possible descriptors. UNIX gives standard functions to access the message passing feature.;
msgget: This system call takes a key as an argument and returns a descriptor of the queue with the matching key if it exists. If it does not exist, and the IPC_CREAT flag is set, it makes a new message queue with the given key and returns its descriptor.;
msgrcv: Used to receive a message from a given queue descriptor. The caller process must have read permissions for the queue. It is of two types.;
msgctl: Used to change message queue parameters like the owner. Most importantly, it is used to delete the message queue by passing the IPC_RMID flag. A message queue can be deleted only by its creator, owner, or the superuser.POSIX
The POSIX.1-2001 message queue API is the later of the two UNIX message queue APIs. It is distinct from the SYS V API, but provides similar function. The unix man pagemq_overview provides an overview of POSIX message queues.Graphical user interfaces
s employ a message queue, also called an event queue or input queue, to pass graphical input actions, such as mouse clicks, keyboard events, or other user inputs, to the application program. The windowing system places messages indicating user or other events, such as timer ticks or messages sent by other threads, into the message queue. The GUI application removes these events one at a time by calling a routine calledgetNextEvent or similar in an event loop, and then calling the appropriate application routine to process that event.