Strategy A: Linearizable Execution (Sync)

Strategy A: Linearizable Execution (Sync)

Linearizability is the strongest consistency model, where operations appear to take effect instantaneously and only once between their invocation and completion times, maintaining a global order [1]. This is crucial for high-criticality intents in healthy system states to prevent data inconsistencies. However, implementing linearizability via synchronous blocking and global locks significantly degrades throughput by precluding parallelism.

In Kafka, linearizable durability is achieved by setting ‘acks=all’ or ‘acks=-1’, ensuring that a write is not considered committed until all in-sync replicas have acknowledged it [2]. Enabling producer idempotence in Kafka requires ‘acks’ to be set to ‘all’ to ensure exactly-once semantics during retries. The SYNC strategy is specifically triggered when Intent Criticality is ‘High’ and System Health is ‘Good’, necessitating immediate persistence and full constraints.

Implementation Considerations

The implementation of a blocking write with quorum verification using Kafka and Java Records is as follows:

public record IntentResult(String transactionId, Status status) {}

public class LinearizableStrategy {
    private final KafkaProducer<String, Intent> producer;

    public IntentResult executeSync(Intent intent) {
        try {
            // Blocking write with quorum (acks=all mandated by config)
            RecordMetadata metadata = producer.send(new ProducerRecord<>("intents", intent.id(), intent)).get();
            return new IntentResult(intent.id(), Status.COMMITTED);
        } catch (InterruptedException | ExecutionException e) {
            throw new ConsistencyException("Failed to reach quorum for intent: " + intent.id(), e);
        }
    }
}

This approach ensures that no stale read can occur even if the leader fails, maintaining linearizability.

Throughput and Latency Comparison

The following table compares the throughput and latency of Linearizable and Asynchronous strategies:

As shown, the Linearizable strategy prioritizes consistency and durability over throughput and availability, making it suitable for high-criticality applications.

Sources

[1] Herlihy and Wing. (1990). Linearizability: A Correctness Criterion for Concurrent Objects. [2] https://charap.co/review-implementing-linearizability-at-large-scale-and-low-latency/ [3] https://bravenewgeek.com/tag/linearizability/