At-most-once delivery
At-most-once delivery is a messaging guarantee that each message is delivered no more than once, so messages may be lost but are not duplicated.
Kafka Streams in Action, Second Edition
At-most-once delivery is a processing guarantee that avoids reprocessing by committing before processing completes, at the risk of losing records.
- How it is used
- Uses early acknowledgment or offset commitment when avoiding duplicate processing matters more than recovering every record.
- How deep it goes
- Explains producer acknowledgments, consumer commit timing, restart behavior, and asynchronous-processing hazards without developing a complete application.
- Examples
- Uses producer acks=0, manual batch commits, consumer restarts, and asynchronous processing as concrete cases.
- What you can do after
- Operate/configure Kafka producers with acks=0 and consumers that commit offsets before processing, while recognizing the resulting loss risk.
Read how Kafka Streams in Action, Second Edition explains at-most-once delivery →
Think Distributed Systems
A message-delivery guarantee in which each sent message is delivered zero or one time.
- How it is used
- Frames message delivery and processing guarantees for request-response systems under component, network, crash, and recovery failures.
- How deep it goes
- Defines zero-or-one delivery, contrasts sender retry choices, and stops short of guaranteeing exactly-once processing.
- Examples
- Uses request-response dialogues, TCP acknowledgment, and two request-tracking orderings around a transfer-balance side effect.
- What you can do after
- Evaluate delivery guarantees and explain why stopping after silence differs from retrying, especially when TCP underlies application messaging.
Read how Think Distributed Systems explains at-most-once delivery →
C# Concurrency: Asynchronous and multithreaded programming
At-most-once delivery is a message-delivery guarantee that delivers a message zero or one time and does not intentionally retry it after loss.
- How it is used
- Chooses loss over duplicate processing when removing queued work before execution is acceptable.
- How deep it goes
- Defines the guarantee through a crash scenario and contrasts it with at-least-once and usually impossible exactly-once delivery.
- Examples
- Uses power loss between queue removal and processing as its concrete failure example.
- What you can do after
- Evaluate whether message loss is preferable to duplicate processing when selecting a persistent-queue guarantee.
Read how C# Concurrency: Asynchronous and multithreaded programming explains at-most-once delivery →
Apache Kafka in Action
At-most-once delivery is a message delivery guarantee that permits message loss but prohibits duplicate delivery.
- How it is used
- Uses acks=0 when high-volume measurements can be lost but must not appear twice.
- How deep it goes
- Defines the guarantee, explains its acknowledgment mechanism, and contrasts its loss trade-off with other delivery guarantees.
- Examples
- Uses continuous temperature readings as an acceptable-loss case and banking transactions as a duplicate-sensitive contrast.
- What you can do after
- Operate/configure Kafka producers with acks=0 when avoiding duplicates outweighs guaranteed message arrival.
Read how Apache Kafka in Action explains at-most-once delivery →
Akka in Action, Second Edition
An at-most-once delivery guarantee means each record is delivered zero or one time, so records may be lost but are not redelivered.
- How it is used
- Uses the guarantee for simple actor messaging and Kafka production when acknowledgment or stronger processing guarantees are unnecessary.
- How deep it goes
- Explains loss and non-redelivery through actor failures and implements Kafka production, while stopping short of delivery internals.
- Examples
- Demonstrates stopped actors, worker timeouts, Kafka ProducerRecord values, plainSink, kcat output, and records numbered one through ten.
- What you can do after
- Apply it via Akka actors or Alpakka Kafka by sending messages once and selecting Producer.plainSink for topic production.
Read how Akka in Action, Second Edition explains at-most-once delivery →
Related concepts
- at-least-once deliverycontrasts with · At-least-once delivery is a messaging or processing guarantee that each message or record is delivered or processed one or more times, so duplicates may occur.
- acks=0configured by · acks=0 is a Kafka producer setting that requires no acknowledgment from the broker and provides no delivery or persistence guarantee.
- exactly-once deliverycontrasts with · Exactly-once delivery is a messaging or processing guarantee that each message or input produces its intended effect once, without loss or duplicate effects, despite retries or failures.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.