The task was about writing a controller for a remotely-controlled drone, and its controls were accessible over gRPC.

I remember it not just because it was fun, but because I had an eureka moment – in my university, we went through a similar problem, which allowed me to implement the solution right away. That solution was a PID controller.

PID Controllers?

PID Controllers are one of the most widely used control mechanisms in engineering. They adjust a system’s control input to keep a process variable at a desired value while accounting for momentum and avoiding overshoots.

The underlying algorithm is surprisingly simple. The basic idea behind any feedback controller loop is trivial:

1. measure the current state
2. compare it with the target
3. adjust

However, there are various ways for us to utilize that difference between the measured value and the setpoint.

We’ll use a cruise control simulation as our running example, which should make the behavior of each controller variant easy to reason about.

Step 1: Naive Proportional Controller (P)

Let’s say we want to get to and maintain a setpoint of 100 km/h.

double error = setpoint - measured;

The setpoint is our target, measured is where we are right now, and error is the gap between the two.

The most obvious approach is to push hard when we’re far from the target and push gently when we’re close:

record PController(double kp) {

    double compute(double setpoint, double measured) {
        double error = setpoint - measured;
        return kp * error;
    }
}

The controller parameter kp controls how aggressively the controller reacts by making the output proportional to the error. That’s where P comes from.

Let’s see it in action. Simulating those scenarios is actually easier than expected:

• throttle accelerates the car
• drag slows it down (and doesn’t change, at least for now)

Drag’s existence means that the car needs continuous throttle just to maintain speed.

// double TARGET_SPEED = 100.0;
// double DRAG = 0.1;
// double DT = 0.1;
// int STEPS = 1000;

var controller = new PController(1.0);
double speed = 0;

for (int i = 0; i < STEPS; i++) {
    double throttle = controller.compute(TARGET_SPEED, speed);
    speed += (throttle - DRAG * speed) * DT;
    System.out.println(i + ": speed = " + speed);
}

Let’s have a look at the results:

As we get closer to the target speed, the error shrinks, and the throttle decreases, but drag keeps pulling the speed down, and we end up with a phenomenon called steady-state error.

It’s the fundamental limitation of proportional-only control.

We need to address this somehow.

Step 2: Proportional-Derivative Controller (PD)

The problem with the above solution is that it doesn’t acknowledge momentum in any way. It doesn’t care if the error is increasing/decreasing – it sees just the difference.

In order to do something about this, we need to start looking at the error’s rate of change, which means we need to start tracking previous error:

private double previousError;

And then calculate the rate of change (derivative):

double rateOfChange = (error - previousError) / dt;

And incorporate it into the equation:

return kp * error + kd * rateOfChange;

And here’s our new implementation:

class PDController {

    private final double kp;
    private final double kd;

    private double previousError;

    PDController(double kp, double kd) {
        this.kp = kp;
        this.kd = kd;
    }

    double compute(double setpoint, double measured, double dt) {
        double error = setpoint - measured;
        double rateOfChange = (error - previousError) / dt;
        previousError = error;
        return kp * error + kd * rateOfChange;
    }
}

Let’s see it in action:

The result is a much smoother response, but it doesn’t help with the core issue much. At the end of the day, the rate of change of a constant error is close to zero, so in the long run, we’re back to the same P-only behavior.

Let’s try something else.

Step 3: Proportional-Integral Controller (PI)

To close that persistent gap, we need something that accumulates error over time.

If you recall calculus, an integral represents the area under a curve. Here, the curve is our error over time, and integral += error * dt is just us summing up tiny rectangles of width dt and height error, so the longer the error persists, the larger the area grows, which results in throttle increase:

class PIController {

    private final double kp;
    private final double ki;

    private double integral;

    PIController(double kp, double ki) {
        this.kp = kp;
        this.ki = ki;
    }

    double compute(double setpoint, double measured, double dt) {
        double error = setpoint - measured;
        integral += error * dt;
        return kp * error + ki * integral;
    }
}

Let’s see it in action:

Whoa! This actually works! Our car actually reaches 100km/h! Our integral makes sure that as long as there’s error, throttle adjusts, so the controller never settles below/above the target.

However, if you look closely, you can see that it oscillates a bit.

This is already pretty good for many real-world systems where overshoot isn’t a problem.

However, there’s one more thing we need to address. Our PI controller has no output limits so let’s add output clamping:

return Math.clamp(output, outputMin, outputMax);

And let’s see what happens.

Whoa! that’s actually much worse! That massive overshoot and oscillation is caused by a phenomenon called integral windup.

During startup, the car is at 0 km/h and the target is 100 km/h. The error is large, and the integral term keeps accumulating it every time step so it just piles up silently.

When the car reaches 100 km/h, the integral has grown huge. Even though the error is now zero, the accumulated integral causes massive overshoot. The controller then has to offload (or rather unwind) all that accumulated integral.

The fix is straightforward: when the output hits the min/max limits, we undo the last integral accumulation:

if (output > outputMax) {
    accumulatedError -= error * dt;
    return outputMax;
}
if (output < outputMin) {
    accumulatedError -= error * dt;
    return outputMin;
}

This way, the integral only accumulates when the controller’s output is actually being used.

The difference is drastic:

But our controller still oscillates more than it should. Let’s bring back the derivative term.

Step 4: Full PID Controller

In order to end up with the ultimate solution, we need to combine all three approaches into a single controller that eliminates steady-state error and dampens overshoot.

We already know about windup protection, so let’s bake it in from the start:

class PIDController {

    private final double kp;
    private final double ki;
    private final double kd;
    private final double outputMin;
    private final double outputMax;

    private double accumulatedError;
    private double previousError;

    PIDController(double kp, double ki, double kd, double outputMin, double outputMax) {
        this.kp = kp;
        this.ki = ki;
        this.kd = kd;
        this.outputMin = outputMin;
        this.outputMax = outputMax;
    }

    double compute(double setpoint, double measured, double dt) {
        double error = setpoint - measured;

        accumulatedError += error * dt;
        double changeRate = (error - previousError) / dt;
        previousError = error;

        double output = kp * error + ki * accumulatedError + kd * changeRate;

        if (output > outputMax) {
            accumulatedError -= error * dt;
            return outputMax;
        }
        if (output < outputMin) {
            accumulatedError -= error * dt;
            return outputMin;
        }
        return output;
    }
}

Each term handles a different aspect of the control problem now, but the final result doesn’t seem significantly better than the previous result:

Tuning

The implementation of PID is easy, but it’s the tuning that’s hard. The right values depend entirely on the system being controlled, and the trade-offs between responsiveness, overshoot, and stability.

Let’s see what a difference tuning makes for our cruise control. Here are four parameter sets, all using the same PID controller:

So how did I do it? Well, good old trial and error. While this might sound disappointing, quite often it’s the most pragmatic choice in real life systems. However, for formal approaches, look into the Ziegler-Nichols method or Cohen-Coon tuning.

Here are a few tips to make your trial and error easier:

• p controls how aggressively system responds, but if you increase it too much, you’ll get oscillations
• i removes steady-state offset, but too much of it makes the system sluggish
• d smoothes the response, but can amplify noise

As a bonus, here’s our tuned controller running though disturbances:

Source Code

As always, the source code is available on GitHub.

The post Implementing a PID Controller in Java appeared first on { 4Comprehension }.

However, what if someone wanted to implement a custom intermediate operation? While most of those you could shoehorn into the Collectors API, it has one major limitation – Collectors evaluate the whole Stream without any short-circuiting. This is precisely what Gatherers are for.

More about them in the upcoming article, but today we’ll go through a case study of implementing an efficient Gatherer that takes N last Stream elements (think limit() but from the other side).

This example is not about short-circuiting; it’s about implementing an intermediate operation efficiently without materialising the whole stream first.

Implementing Gatherers

Implementing Gatherers is similar to implementing Collectors, but with one major difference – the Integrator:

public interface Gatherer<T, A, R> {
    Supplier<A> initializer();
    Integrator<A, T, R> integrator();
    BinaryOperator<A> combiner();
    BiConsumer<A, Downstream<? super R>> finisher();
}

Integrator is what allows signalling up that a Stream should stop pushing new elements by returning a boolean indicator:

boolean integrate(A state, T element, Downstream<? super R> downstream);

However, in our case, we’ll not be leveraging this.

Our goal is to implement a gatherer that returns the last N elements of a given Stream:

Stream.of(1,2,3,4)
  .gather(last(2))
  .forEach(...); 

// 3, 4

Now, we’ll go through a few iterations: start simple, and then see what we can do to make it perform better.

Step 1: Make it Right

Probably the easiest way to end up with something that produces correct results is to use a List to accumulate the last N elements and update it whenever new elements arrive.

Firstly, we need to initialize our accumulator:

@Override
public Supplier<ArrayList<T>> initializer() {
    return ArrayList::new;
}

@Override
public Integrator<ArrayList<T>, T, T> integrator() {
    return Integrator.ofGreedy((state, elem, ignored) -> {
        if (state.size() >= n) {
            state.removeFirst();
        }
        state.add(elem);
        return true;
    });
}

And finally, we need to push those elements downstream in the finalizer:

@Override
public BiConsumer<ArrayList<T>, Downstream<? super T>> finisher() {
    return (state, downstream) -> {
        for (T e : state) {
            if (!downstream.push(e)) {
                break;
            }
        }
    };
}

public record LastGathererTake1<T>(int n) implements Gatherer<T, ArrayList<T>, T> {

    @Override
    public Supplier<ArrayList<T>> initializer() {
        return ArrayList::new;
    }

    @Override
    public Integrator<ArrayList<T>, T, T> integrator() {
        return Integrator.ofGreedy((state, elem, ignored) -> {
            if (state.size() >= n) {
                state.removeFirst();
            }
            state.add(elem);
            return true;
        });
    }

    @Override
    public BiConsumer<ArrayList<T>, Downstream<? super T>> finisher() {
        return (state, downstream) -> {
            for (T e : state) {
                if (!downstream.push(e)) {
                    break;
                }
            }
        };
    }
}

@Benchmark
public void take_1(Blackhole bh) {
    Stream.of(data)
      .gather(new LastGathererTake1<>(n))
      .forEach(bh::consume);
}

Benchmark             (n)   (size)  Mode Cnt Score   Error   Units
LastBenchmark.take_1 1000 10000000 thrpt   3 1,338 ± 0,239   ops/s

public record LastGathererTake2<T>(int n) implements Gatherer<T, ArrayList<T>, T> {

    @Override
    public Supplier<ArrayList<T>> initializer() {
        return ArrayList::new;
    }

    @Override
    public Integrator<ArrayList<T>, T, T> integrator() {
        return Gatherer.Integrator.ofGreedy((state, elem, ignored) -> {
              state.add(elem);
              return true;
          }
        );
    }

    @Override
    public BiConsumer<ArrayList<T>, Downstream<? super T>> finisher() {
        return (state, downstream) -> {
            int start = Math.max(0, state.size() - n);
            for (int i = start; i < state.size(); i++) {
                if (!downstream.push(state.get(i))) {
                    break;
                }
            }
        };
    }
}

Benchmark             (n)  (size)   Mode Cnt Score   Error Units
LastBenchmark.take_1 1000 10000000 thrpt  3  1,348 ± 0,201 ops/s
LastBenchmark.take_2 1000 10000000 thrpt  3 19,052 ± 7,252 ops/s

public record LastGathererTake3<T>(int n) implements Gatherer<T, ArrayDeque<T>, T> {

    @Override
    public Supplier<ArrayDeque<T>> initializer() {
        return ArrayDeque::new;
    }

    @Override
    public Integrator<ArrayDeque<T>, T, T> integrator() {
        return Integrator.ofGreedy((state, element, ignored) -> {
            if (state.size() == n) {
                state.removeFirst();
            }
            state.addLast(element);
            return true;
        });
    }

    @Override
    public BiConsumer<ArrayDeque<T>, Downstream<? super T>> finisher() {
        return (state, ds) -> {
            for (Iterator<T> it = state.iterator(); it.hasNext() && !ds.isRejecting(); ) {
                if (!ds.push(it.next())) {
                    break;
                }
            }
        };
    }
}

Benchmark             (n)   (size) Mode Cnt Score    Error  Units
LastBenchmark.take_1 1000 10000000 thrpt 3  1,340  ± 0,032  ops/s
LastBenchmark.take_2 1000 10000000 thrpt 3  17,685 ± 33,776 ops/s
LastBenchmark.take_3 1000 10000000 thrpt 3  35,751 ± 3,629  ops/s

static class AppendOnlyCircularBuffer<T> {
    private final T[] buffer;
    private int endIdx = 0;
    private int size = 0;

    public AppendOnlyCircularBuffer(int size) {
        this.buffer = (T[]) new Object[size];
    }

    public void add(T element) {
        buffer[endIdx++ % buffer.length] = element;
        if (size < buffer.length) {
            size++;
        }
    }

    public void forEach(Consumer<T> consumer) {
        int startIdx = (endIdx - size + buffer.length) % buffer.length;
        for (int i = 0; i < size; i++) {
            consumer.accept(buffer[(startIdx + i) % buffer.length]);
        }
    }
}

Benchmark             (n)  (size)  Mode  Cnt Score  Error    Units
LastBenchmark.take_1 1000 10000000 thrpt 3   1,360  ± 0,216  ops/s
LastBenchmark.take_2 1000 10000000 thrpt 3   19,060 ± 28,949 ops/s
LastBenchmark.take_3 1000 10000000 thrpt 3   38,050 ± 8,296  ops/s
LastBenchmark.take_4 1000 10000000 thrpt 3   84,340 ± 15,607 ops/s

public void add(T element) {
    buffer[endIdx++ % buffer.length] = element;
    if (size < buffer.length) {
        size++;
    }
}

0x0000000112afe244: sdiv w8, w3, w4
0x0000000112afe248: msub w3, w8, w4, w3 ;*irem {reexecute=0 rethrow=0 return_oop=0}

One of the classic tricks involves replacing modulo operation with bit masking, but there’s a catch – it works only when modulus is a power of two. We can’t guarantee our modulus to be a power of two… or can we?

Nothing is stopping us from aligning our buffer’s size to the next available power of two. We’d just need to be careful to read last N elements properly.

First, we’d need to have an efficient method of finding it:

private static int nextPowerOfTwo(int x) {
    int highest = Integer.highestOneBit(x);
    return (x == highest) ? x : (highest << 1);
}

Now, we’d need to use it to initialize buffer and a mask:

int capacity = nextPowerOfTwo(Math.max(1, this.limit));
this.buffer = new Object[capacity];
this.mask = capacity - 1;

void add(T e) {
    buffer[writeIdx & mask] = e;
    writeIdx++;
    if (size < limit) {
        size++;
    }
}

T get(int index, int start) {
    return (T) buffer[(start + index) & mask];
}

void pushAll(Gatherer.Downstream<? super T> ds) {
    int start = (writeIdx - size) & mask;

    for (int i = 0; i < size && !ds.isRejecting(); i++) {
        if (!ds.push(get(i, start))) {
            break;
        }
    }
}

final class AppendOnlyCircularBuffer<T> {
    private final Object[] buffer;
    private final int mask;
    private final int limit;

    private int size;
    private int writeIdx;

    AppendOnlyCircularBuffer(int limit) {
        this.limit = Math.max(0, limit);
        int capacity = nextPowerOfTwo(Math.max(1, this.limit));
        this.buffer = new Object[capacity];
        this.mask = capacity - 1;
    }

    void add(T e) {
        buffer[writeIdx & mask] = e;
        writeIdx++;
        if (size < limit) {
            size++;
        }
    }

    T get(int index, int start) {
        return (T) buffer[(start + index) & mask];
    }

    void pushAll(Gatherer.Downstream<? super T> ds) {
        int start = (writeIdx - size) & mask;

        for (int i = 0; i < size && !ds.isRejecting(); i++) {
            if (!ds.push(get(i, start))) {
                break;
            }
        }
    }

    private static int nextPowerOfTwo(int x) {
        int highest = Integer.highestOneBit(x);
        return (x == highest) ? x : (highest << 1);
    }
}

Benchmark             (n)   (size)  Mode Cnt Score   Error  Units
LastBenchmark.take_1 1000 10000000 thrpt  3  1,352 ± 0,232  ops/s
LastBenchmark.take_2 1000 10000000 thrpt  3 17,885 ± 14,921 ops/s
LastBenchmark.take_3 1000 10000000 thrpt  3 38,229 ± 1,599  ops/s
LastBenchmark.take_4 1000 10000000 thrpt  3 89,591 ± 18,486 ops/s
LastBenchmark.take_5 1000 10000000 thrpt  3 100,454 ± 1,073 ops/s

Our implementation does a few things we never asked for.

For example, in the below, the size/limit comparison runs on every element even though once the buffer fills, it never does anything again:

void add(T e) {
    buffer[writeIdx & mask] = e;
    writeIdx++;
    if (size < limit) {
        size++;
    }
}

We don’t really need this value until the very end so there’s no reason to maintain it element by element – we can keep a single monotonic counter and work out size once, in the finisher:

int size = (int) Math.min(count, limit);

That’s the easy one, but there’s also the other one, which is way more sneaky:

buffer[writeIdx & mask] = e

We know that writeIdx & mask always lands inside the array – this is the whole point of that power-of-two size adjustment. However, for JIT mask is just some int field initialized outside the analysis scope.

The irony is: we tried to help JIT by precomputing the mask, but it made things worse!

The solution is to just inline the computation:

buffer[(int) count & (buffer.length - 1)] = e;
count++;

record SingleElementLastGatherer<T>() implements Gatherer<T, SingleElementLastGatherer.ValueHolder<T>, T> {

    @Override
    public Supplier<ValueHolder<T>> initializer() {
        return ValueHolder::new;
    }

    @Override
    public Integrator<ValueHolder<T>, T, T> integrator() {
        return Integrator.ofGreedy((state, element, _) -> {
            state.value = element;
            state.isSet = true;
            return true;
        });
    }

    @Override
    public BiConsumer<ValueHolder<T>, Downstream<? super T>> finisher() {
        return (state, downstream) -> {
            if (state.isSet && !downstream.isRejecting()) {
                downstream.push(state.value);
            }
        };
    }

    static class ValueHolder<T> {
        private T value;
        private boolean isSet;
    }
}

Benchmark      (n) (size)  Mode Cnt Score        Error        Units
circular_buffer 1 10000000 thrpt 3  100,963      ± 1,941      ops/s
value_holder    1 10000000 thrpt 3  46678566,613 ± 340533,213 ops/s

static <T> Gatherer<T, ?, T> last(int n) {
    return switch (n) {
        case 1 -> new SingleElementLastGatherer<>();
        default -> new CircularBufferLastGatherer<>(n);
    };
}

Benchmark     (n)   (size)   Mode Cnt Score        Error   Units
gatherers4j    1    10000000 thrpt 3  33,746       ± 1,762 ops/s
gatherers4j    10   10000000 thrpt 3  32,794       ± 0,291 ops/s
gatherers4j    100  10000000 thrpt 3  33,068       ± 0,135 ops/s
gatherers4j    1000 10000000 thrpt 3  33,388       ± 0,754 ops/s
more_gatherers 1    10000000 thrpt 3  46719898,497 ± 1661311,151 ops/s
more_gatherers 10   10000000 thrpt 3  124,397      ± 13,737 ops/s
more_gatherers 100  10000000 thrpt 3  124,481      ± 14,503 ops/s
more_gatherers 1000 10000000 thrpt 3  124,480      ± 1,520 ops/s

The post Implementing Efficient Last Stream Elements Gatherer in Java appeared first on { 4Comprehension }.

This is impossible if you rely on mocks that verify whether some implementation details were called or not. Mocks push you to design internal components first.

A common concern, however, is that fake implementations can gradually drift away from the real ones, leading your tests to validate a homegrown blob rather than the real thing.

Let me show you a great trick that can minimize this drift.

Fakes vs Mocks

First things first, let’s address a common misconception.

Many developers casually call any test double a mock, but that’s not accurate and can lead to misunderstandings.

What distinguishes a mock from a stub is method call expectations. We’re essentially verifying if some method of some component was called:

var emailService = Mockito.mock(EmailService.class);
// ...
Mockito.verify(emailService).send("alice@example.com", "Welcome!");

The irony is, if you’re using Mockito.mock() only to make it return predefined values, you’re not really creating a mock – you’ve created a stub instead.

When I say “avoid mocks” in favour of fakes, it’s not a contradiction. The key is that fakes help you test behavior, whereas mocks encourage coupling your tests to implementation details.

Now, let’s get to the main point.

Minimizing Fake Drift with JUnit 6

In order for a fake to be useful, it needs to mirror the behaviour of the thing it’s supposed to fake.

Obviously, it doesn’t mean that you need to reimplement all Postgres functionality in your in-memory fake, and if some functionality is too hard to mimic, the pragmatic move would be to simply… just rely on integration tests instead.

As a rule of thumb, if a fake is not immediately obvious how to implement, you should probably not do it. Typical examples include geospatial queries, full-text search, or transaction isolation, and locking semantics, etc.

Luckily, most cases are much simpler than that.

Let’s start with a simple CRUD example:

public interface MovieRepository {
    long save(Movie movie);
    List<Movie> findAll();
    List<Movie> findAllByType(String type);
    Optional<Movie> findById(long id);
}

public record Movie(String title, String type) {
}

abstract class MovieRepositoryTest {
    abstract MovieRepository getRepository();

    private MovieRepository repository;

    @BeforeEach
    void setUp() {
        repository = getRepository();
    }

    // compressed into a single case for convenience
    @Test
    void shouldSaveAndFetchMovie() {
        var m1 = new Movie("Tenet", "NEW");
        var m2 = new Movie("Casablanca", "OLD");

        assertThat(repository.findAll()).isEmpty();

        long id1 = repository.save(m1);
        long id2 = repository.save(m2);

        assertThat(repository.findAll())
          .containsExactlyInAnyOrder(m1, m2);
        assertThat(repository.findAllByType("NEW"))
          .containsExactly(m1);
        assertThat(repository.findById(id1)).hasValue(m1);
        assertThat(repository.findById(id2)).hasValue(m2);
    }

// ...
}

CREATE TABLE movies
(
    id    SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    type  TEXT NOT NULL
);

public class PostgresMovieRepository implements MovieRepository {

    private final Jdbi jdbi;

    public PostgresMovieRepository(DataSource dataSource) {
        this.jdbi = Jdbi.create(dataSource)
          .installPlugin(new PostgresPlugin());
    }

    @Override
    public long save(Movie movie) {
        return jdbi.withHandle(handle ->
          handle.createQuery("INSERT INTO movies (title, type) VALUES (:title, :type) RETURNING id")
            .bind("title", movie.title())
            .bind("type", movie.type())
            .mapTo(Long.class)
            .one()
        );
    }

    @Override
    public List<Movie> findAll() {
        return jdbi.withHandle(handle ->
          handle.createQuery("SELECT title, type FROM movies")
            .map(toMovie())
            .list()
        );
    }

    @Override
    public List<Movie> findAllByType(String type) {
        return jdbi.withHandle(handle ->
          handle.createQuery("SELECT title, type FROM movies WHERE type = :type")
            .bind("type", type)
            .map(toMovie())
            .list()
        );
    }

    @Override
    public Optional<Movie> findById(long id) {
        return jdbi.withHandle(handle ->
          handle.createQuery("SELECT title, type FROM movies WHERE id = :id")
            .bind("id", id)
            .map(toMovie())
            .findOne()
        );
    }

    private static RowMapper<Movie> toMovie() {
        return (rs, _) -> new Movie(rs.getString("title"), rs.getString("type"));
    }
}

@Testcontainers
class PostgresMovieRepositoryTest extends MovieRepositoryTest {

    private static final Logger log = LoggerFactory
      .getLogger(PostgresMovieRepositoryTest.class);

    @Container
    static final PostgreSQLContainer postgres = new PostgreSQLContainer("postgres:18")
      .withNetworkAliases("postgres")
      .withDatabaseName("postgres")
      .withUsername("postgres")
      .withPassword("password")
      .withLogConsumer(new Slf4jLogConsumer(log).withPrefix("postgres"))
      .waitingFor(Wait.forListeningPort());

    @Override
    MovieRepository getRepository() {
        return new PostgresMovieRepository(getDatasource());
    }

    private DataSource getDatasource() {
        PGSimpleDataSource ds = new PGSimpleDataSource();
        ds.setUrl(postgres.getJdbcUrl());
        ds.setPassword(postgres.getPassword());
        ds.setUser(postgres.getUsername());

        Flyway.configure()
          .dataSource(ds)
          .locations("classpath:db/migration")
          .load()
          .migrate();

        return ds;
    }
}

public class InMemoryFakeMovieRepository implements MovieRepository {

    private final Map<Long, Movie> movies = new ConcurrentHashMap<>();

    @Override
    public long save(Movie movie) {
        long id = ThreadLocalRandom.current().nextLong();
        movies.put(id, movie);
        return id;
    }

    @Override
    public List<Movie> findAll() {
        return List.copyOf(movies.values());
    }

    @Override
    public List<Movie> findAllByType(String type) {
        return movies.values().stream()
          .filter(movie -> movie.type().equals(type))
          .toList();
    }

    @Override
    public Optional<Movie> findById(long id) {
        return Optional.ofNullable(movies.get(id));
    }
}

class FakeMovieRepositoryTest extends MovieRepositoryTest {

    @Override
    MovieRepository getRepository() {
        return new InMemoryFakeMovieRepository();
    }
}

ALTER TABLE movies
    ADD CONSTRAINT movies_title_not_empty CHECK (title <> '');

ALTER TABLE movies
    ADD CONSTRAINT movies_type_not_empty CHECK (type <> '');

@Override
public long save(Movie movie) {
    try {
        return jdbi.withHandle(handle ->
          handle.createQuery("INSERT INTO movies (title, type) VALUES (:title, :type) RETURNING id")
            .bind("title", movie.title())
            .bind("type", movie.type())
            .mapTo(Long.class)
            .one()
        );
    } catch (UnableToExecuteStatementException e) {
        if (e.getCause() instanceof PSQLException psqle) {
            switch (psqle.getSQLState()) {
                case "23502": throw new IllegalArgumentException("Movie title cannot be blank", e);
                case "23514": throw new IllegalArgumentException("Movie title cannot be null", e);
            }
        }
        throw new RuntimeException(e);
    }
}

@Test
void shouldRejectMovieWithEmptyTitle() {
    assertThatThrownBy(() -> repository.save(new Movie("", "NEW")))
      .isInstanceOf(IllegalArgumentException.class);
}

@Test
void shouldRejectMovieWithNullTitle() {
    assertThatThrownBy(() -> repository.save(new Movie(null, "NEW")))
      .isInstanceOf(IllegalArgumentException.class);
}

@Override
public long save(Movie movie) {
    if (movie.title() == null || movie.title().isBlank()) {
        throw new IllegalArgumentException("Movie title cannot be blank or null");
    }

    long id = ThreadLocalRandom.current().nextLong();
    movies.put(id, movie);
    return id;
}

The post Avoiding Fake Drift in Unit Tests appeared first on { 4Comprehension }.

Naturally, the approach has evolved significantly over the last couple of years. Let’s explore all the options!

Context and Thread Locals – The Core of The Issue

What’s context? (the concept, not Context class). It’s essentially a collection of information that provides the relevant background or state needed to execute a task correctly.

Imagine you’re dining at a restaurant. Your table number, order details, and special requests all form an execution context.

One way of handling it would be to have your waiter memorize all the details, which would work great if you had guarantees that the same waiter would serve you during the whole task execution lifecycle dinner.

This is your ThreadLocal storage! And when you see ThreadLocal<X>, think Map<Thread, X>.

public static void main(String[] args) throws InterruptedException {
    // think Map<Waiter, OrderDetails>
    ThreadLocal<OrderDetails> preferences = new ThreadLocal<>();

    Thread waiter1 = Thread.ofPlatform().start(() -> {
        preferences.set(new OrderDetails("lactose-free"));

        System.out.printf("preferences: %s%n", preferences.get());
    });

    waiter1.join();

    Thread waiter2 = Thread.ofPlatform().start(() -> {
        System.out.printf("preferences: %s%n", preferences.get());
    });

    waiter2.join();
}

public record OrderDetails(String preferences) {
}

preferences: OrderDetails[preferences=lactose-free]
preferences: null

public static void main(String[] args) {
    ThreadLocal<String> preferences = new ThreadLocal<>();

    preferences.set("lactose-free");

    Mono.just("table 42")
      .publishOn(Schedulers.newSingle("waiter"))
      .map(i -> {
          System.out.printf("preferences: %s, thread: %s%n", preferences.get(), Thread.currentThread().getName());
          return i;
      })
      .publishOn(Schedulers.newSingle("barista"))
      .map(i -> {
          System.out.printf("preferences: %s, thread: %s%n", preferences.get(), Thread.currentThread().getName());
          return i;
      })
      .block();

    // preferences: null, thread: waiter-1
    // preferences: null, thread: barista-2
}

Mono.just("table 42")
  // ...
  .contextWrite(Context.of("preferences", "lactose-free"))
  .block();

.map(i -> i.toUpperCase())

.flatMap(i -> Mono.deferContextual(ctx -> Mono.just(i.toUpperCase())))

Mono.just("table 42")
  .publishOn(Schedulers.newSingle("waiter"))
  .flatMap(i -> Mono.deferContextual(ctx -> {
      System.out.printf("preferences: %s, thread: %s%n", ctx.get("preferences"), Thread.currentThread().getName());
      // ...
      return Mono.just(i);
  }))
  .publishOn(Schedulers.newSingle("barista"))
  .flatMap(i -> Mono.deferContextual(ctx -> {
      System.out.printf("preferences: %s, thread: %s%n", ctx.get("preferences"), Thread.currentThread().getName());
      // ...
      return Mono.just(i);
  }))
  .contextWrite(Context.of("preferences", "lactose-free"))
  .block();

// preferences: lactose-free, thread: waiter-1
// preferences: lactose-free, thread: barista-2

String preferences = "lactose-free";

Mono.just("table 42")
  .publishOn(Schedulers.newSingle("waiter"))
  .map(i -> {
      System.out.printf("preferences: %s, thread: %s%n", preferences, Thread.currentThread().getName());
      // ...
      return i;
  })
  .publishOn(Schedulers.newSingle("barista"))
  .map(i -> {
      System.out.printf("preferences: %s, thread: %s%n", preferences, Thread.currentThread().getName());
      // ...
      return i;
  })
  .block();

// preferences: lactose-free, thread: waiter-1
// preferences: lactose-free, thread: barista-2

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <layout>
            <Pattern>%-4r [%thread] %-5level tenantId:%X{tid:-!missing!} - %msg%n</Pattern>
        </layout>
    </appender>

    <root level="info">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

public static void main(String[] args) {

    MDC.put("tid", "4comprehension");

    Mono.just("table 42")
      .publishOn(Schedulers.newSingle("waiter"))
      .map(i -> {
          log.info("processing i");
          // ...
          return i;
      })
      .publishOn(Schedulers.newSingle("barista"))
      .map(i -> {
          log.info("processing i");
          // ...
          return i;
      })
      .block();
}

// 124  [waiter-1] INFO  tenantId:!missing! - processing i
// 125  [barista-2] INFO  tenantId:!missing! - processing i

MDC.put("tid", "4comprehension");

Mono.just("table 42")
  .publishOn(Schedulers.newSingle("waiter"))
  .flatMap(i -> Mono.deferContextual(ctx -> {
      try (var ignored = MDC.putCloseable("tid", ctx.get("tid"))) {
          log.info("processing i");
          // ...
          return Mono.just(i);
      }
  }))
  .publishOn(Schedulers.newSingle("barista"))
  .flatMap(i -> Mono.deferContextual(ctx -> {
      try (var ignored = MDC.putCloseable("tid", ctx.get("tid"))) {
          log.info("processing i");
          // ...
          return Mono.just(i);
      }
  }))
  .contextWrite(Context.of("tid", MDC.get("tid")))
  .block();

// 157  [waiter-1] INFO  tenantId:4comprehension - processing i
// 159  [barista-2] INFO  tenantId:4comprehension - processing i

static <T, R> Function<? super T, Mono<? extends R>> withMDC(Function<? super T, ? extends R> mapper) {
    Objects.requireNonNull(mapper);
    return i -> Mono.deferContextual(ctx -> {
        try (var ignored = MDC.putCloseable("tid", ctx.get("tid"))) {
            return Mono.just(mapper.apply(i));
        }
    });
}

.flatMap(withMDC(i -> {
    log.info("processing i");
    // ...
    return Mono.just(i);
}))

.doOnNext(i -> log.info("processing :{}", i))

.doOnEach(signal -> {
    if (signal.isOnNext()) {
        log.info("processing :{}", signal.get());
    }
})

MDC.put("tid", "4comprehension");

Mono.just("table 42")
  .publishOn(Schedulers.newSingle("waiter"))
  .doOnEach(signal -> {
      if (signal.isOnNext()) {
          try (var ignored = MDC.putCloseable("tid", signal.getContextView().get("tid"))) {
              log.info("processing :{}", signal.get());
          }
      }
  })
  .contextWrite(Context.of("tid", MDC.get("tid")))
  .block();

static <T> Consumer<Signal<? extends T>> withMDC(Consumer<? super T> consumer) {
    return signal -> {
        if (signal.isOnNext()) {
            try (var ignored = MDC.putCloseable("tid", signal.getContextView().get("tid"))) {
                consumer.accept(signal.get());
            }
        }
    };
}

Mono.just("table 42")
  .publishOn(Schedulers.newSingle("waiter"))
  .doOnEach(withMDC(c -> log.info("processing :{}", c)))
  .contextWrite(Context.of("tid", MDC.get("tid")))
  .block();

Hooks.enableAutomaticContextPropagation();

ContextRegistry.getInstance().registerThreadLocalAccessor(new ThreadLocalAccessor<String>() {
    @Override
    public Object key() {
        return "tid";
    }

    @Override
    public String getValue() {
        return MDC.get("tid");
    }

    @Override
    public void setValue(String value) {
        MDC.put("tid", value);
    }

    @Override
    public void setValue() {
        MDC.remove("tid");
    }
});

record Example() {

    private static final Logger log = LoggerFactory.getLogger(Example.class);

    public static void main(String[] args) {

        Hooks.enableAutomaticContextPropagation();

        ContextRegistry.getInstance().registerThreadLocalAccessor(new ThreadLocalAccessor<String>() {
            @Override
            public Object key() {
                return "tid";
            }

            @Override
            public String getValue() {
                return MDC.get("tid");
            }

            @Override
            public void setValue(String value) {
                MDC.put("tid", value);
            }

            @Override
            public void setValue() {
                MDC.remove("tid");
            }
        });

        MDC.put("tid", "4comprehension");

        Mono.just("table 42")
          .publishOn(Schedulers.newSingle("waiter"))
          .map(i -> {
              log.info("processing i");
              // ...
              return i;
          })
          .publishOn(Schedulers.newSingle("barista"))
          .doOnNext(i -> log.info("processing i: {}", i))
          .block();
    }
}

The post Project Reactor: Thread-Locals and Context Propagation appeared first on { 4Comprehension }.

Exception Throwing Overhead

Exceptions are not ordinary POJOs. I mean, they mostly are, but with one extra tiny detail:

public synchronized Throwable fillInStackTrace() {
    // ...
}

This makes exception creation proportional to stack depth because the JVM must eagerly walk the call stack and materialize StackTraceElement objects, and in the world of contemporary frameworks, those can get pretty impressive!

Internally, it’s calling a native method which doesn’t speed things up.

That’s why many performance-critical libraries prefer skipping collecting stack traces, which makes those exceptions easily cacheable.

Netty’s Norman Maurer did benchmark that some time ago, and, as you can see, the difference is significant:

As you can see, the concept is quite trivial. If you want to leverage it, it’s enough to create a static exception instance, reset the stacktrace, and… keep throwing it:

class StaticStacklessExceptionExample {

    private static final NullPointerException NULL_POINTER_EXCEPTION = new NullPointerException();

    static {
        NULL_POINTER_EXCEPTION.setStackTrace(new StackTraceElement[0]);
    }

    public static void main(String[] args) {
        throw NULL_POINTER_EXCEPTION;
    }   
}

JVM Stacktrace Optimization

However, this is where the fun starts. The JVM knows that collecting stacktraces is expensive, and it can optimize them on the spot when they’re needed. By “optimizing”, I mean “dropping”.

Let’s try to reproduce it! In order to do this, we’ll induce a NullPointerException by calling a method on a null String repeatedly and log the results when the stack trace is empty:

class StacktraceDropExample {

    public static void main(String[] args) {
        NullPointerException previous = null;

        String foo = null;
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            try {
                foo.toUpperCase();
            } catch (NullPointerException e) {
                if (e.getStackTrace().length == 0) {
                    System.out.printf("Stacktrace dropped at iteration %d%n", i);
                    if (previous != null) {
                        System.out.printf("Last stacktrace: %s%n",
                          Arrays.toString(previous.getStackTrace()));
                    }
                    System.out.printf("New stacktrace: %s%n",
                      Arrays.toString(e.getStackTrace()));
                    return;
                }
                previous = e;
            }
        }
    }
}

Here’s my result

Stacktrace dropped at iteration 41984
Last stacktrace: [com.pivovarit.exception.StacktraceDropExample.main(StacktraceDropExample.java:14)]
New stacktrace: []

As you can see, we forced the JVM to drop stacktraces of that exception after 41984 iterations! Amazing!

What’s more, let’s try to spice things up. Instead of printing stacktraces, let’s try to collect all witnessed exceptions and count distinct instances according to reference equality:

class ExceptionCacheExample {

    public static void main(String[] args) {
        var exceptions = Collections.newSetFromMap(new IdentityHashMap<>());

        String foo = null;
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            try {
                foo.toUpperCase();
            } catch (NullPointerException e) {
                exceptions.add(e);
            }
        }

        System.out.println(exceptions.size());
    }
}

Note that we can’t use classic HashSet, since we need to rely on reference equality:

Collections.newSetFromMap(new IdentityHashMap<>());

Let’s run it Integer.MAX_VALUE times:

99327

Despite 2147483647 iterations, there were only 99327 distinct instances! This means that JVM started caching exceptions and reusing them!

This behaviour is configurable and can be turned off by using the -XX:-OmitStackTraceInFastThrow switch. When we start the above with this argument, the first example doesn’t print anything, and the second one… consumes all the heap space:

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at com.pivovarit.exception.ExceptionCacheExample.main(ExceptionCacheExample.java:14)

Summary

Creating stackless reusable static instances of Exceptions is one of the classic performance tricks, which JVM can apply automatically under certain circumstances. This can be turned off, but I wouldn’t recommend it since it makes JVMs more resilient when exceptions start falling from the sky.

Also, when you start dropping stack traces on your own, make sure that it brings more value than stack traces themselves, which are quite useful.

Sources

The complete example can be found on GitHub.

The post Has my JVM Lost Exception Stacktraces?! appeared first on { 4Comprehension }.