The Reactive Manifesto lays out key characteristics that define reactive systems.

Core Characteristics

1. Responsiveness: React to events and failures in a timely manner. Ensure application and network latency is minimal.

2. Resilience: Due to potential failures in distributed operations, reactive systems should remain responsive and consistent. They should recover and maintain operations in less than optimal times.

3. Elasticity: Able to manage varying volumes of traffic by scaling resources accordingly.

4. Message-Driven: Communication among system components is achieved through asynchronous message passing rather than more resource-intensive and less flexible mechanisms such as shared memory or method calls.

Additional Characteristics

5. Back-Pressure: Systems should apply back-pressure to prevent resource exhaustion by striving to keep the speed of message production and message processing in balance.

6. Resource Efficiency: They should use resources in a way that ensures the most efficient possible outcome. This means recognizing that resources are limiting and shared and managing them accordingly.

Code Example: Back-Pressure in Akka Streams

Here is the Java code:

final Source<Integer, NotUsed> source = Source.range(1, 100);
final Flow<Integer, Integer, NotUsed> flow = Flow.of(Integer.class).map(i -> i * 2);
final Sink<Integer, CompletionStage<Done>> sink = Sink.foreach(System.out::println);

source.via(flow).to(sink).withAttributes(Attributes.createLogLevels(Logging.DebugLevel(), Logging.InfoLevel()))
    .run(materializer);

Here is the Scala code:

val source = Source(1 to 100)
val flow = Flow[Int].map(_ * 2)
val sink = Sink.foreach[Int](println)

source.via(flow).to(sink).withAttributes(ActorAttributes.dispatcher("my-dispatcher")).run()