32-bit vs 64-bit
    Annotations vs Decorators
    BigQuery vs Bigtable
    Block Storage vs File Storage vs Object Storage
    C vs C++
    Canvas vs SVG
    Constructor vs Init() vs Factory
    Containers vs Virtual Machines (VMs)
    DOM vs Virtual DOM vs Shadow DOM
    DQL vs DDL vs DCL vs DML
    Dagger vs Guice
    Data Mining vs Machine Learning vs Artificial Intelligence vs Data Science
    Flux vs Redux
    GCP API Gateway vs Cloud Endpoint
    GCP Cloud Run vs Cloud Functions vs App Engine
    GCP DataFlow vs Dataproc
    Google Analytics 4 vs Universal Analytics
    Google Internal vs Open Source
    HEIC vs HEIF vs HEVC vs JPEG
    Java vs C++
    Jetty vs Netty
    Kotlin vs Java
    LLVM vs JVM
    Linux vs BSD
    Microcontroller vs Microprocessor vs Computer
    Node.js vs Erlang
    POSIX vs SUS vs LSB
    Pass-by-value vs Pass-by-reference
    Proto2 vs Proto3
    PubSub vs Message Queue
    REST vs SOAP
    React vs Flutter vs Angular
    Rust vs C++
    SLI vs SLO vs SLA
    SRAM vs DRAM
    SSD vs HDD
    Software Engineer vs Site Reliability Engineer
    Spanner vs Bigtable
    Stack based VM vs Register based VM
    Stateless vs Stateful
    Static Site Generation vs Server-side Rendering vs Client-side Rendering
    Strong Consistency vs Eventual Consistency
    Subroutines vs Coroutines vs Generators
    Symlinks vs Hard Links
    Tensorflow vs PyTorch
    Terminal vs Shell
    Vi vs Vim vs gVim vs Neovim
    WAL vs rollback journal
    gtag vs Tag Manager
    stubs vs mocks vs fakes

PubSub vs Message Queue

Updated: 2021-11-26


| Message Queue | PubSub | | ---------------- | ---------------------------------- | ----------------------------------------------- | | Consumers | one and only one consumer | allows multiple consumers | | Message Deletion | after ONE consumer ack consumption | after ALL consumers ack consumption | | Message Order | may be out of order | messages are received in order by each consumer |

Message Queue

  • Each message for a given topic or channel is delivered to and processed by exactly one consumer. (e.g. every paycheck is issued once and only once)
  • can support high rates of consumption by adding multiple consumers for each topic, but only one consumer will receive each message on the topic
  • the message will be deleted once a consumer has acknowledged consumption of the message
  • in the case of network or consumer failures, the message queue will try resending an affected message at a later time (not necessarily to the same consumer) and as a result, that message may be processed out of order.


  • decoupling publishers and subscribers: publishers need not target their messages to specific subscribers nor even know how many subscribers there will be. Publishers and subscribers need not even be running at the same time, and can be implemented in different languages / frameworks. Decoupling often simplifies application design and supports more flexible application scalability.
  • message persistence: messages are kept in permanent storage until they have been acknowledged by all interested subscribers. Persistence allows client applications to be resilient in the face of intermittent application, network, and machine failures.

How to choose

  • Use message queues if a consumer application instance goes down then another consumer will be able to handle the message instead.
  • Use pubsub, if a subscriber is down then once it has recovered the messages it has missed will be available for consumption in its subscribing queue.


Message Queues:

  • ActiveMQ
  • RabbitMQ
  • ZeroMQ

Distributed PubSub:

  • Kafka


  • GCP PubSub
  • Amazon Kinesis