싱글톤과 공유 상태

package board.container;

import static java.util.concurrent.TimeUnit.SECONDS;
import static org.assertj.core.api.Assertions.assertThat;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

final class SingletonStateOwnershipTest {
    @Test
    void 같은_context의_반복_조회는_같고_독립_context는_다르다() {
        try (var first = context();
             var second = context()) {
            var firstLookup =
                    first.getBean(StatefulPageCalculator.class);
            var repeatedLookup =
                    first.getBean(StatefulPageCalculator.class);
            var secondContextLookup =
                    second.getBean(StatefulPageCalculator.class);

            assertThat(firstLookup).isSameAs(repeatedLookup);
            assertThat(firstLookup)
                    .isNotSameAs(secondContextLookup);
        }
    }

    @Test
    void 공유_field가_두_호출의_값을_섞는_순서를_고정한다()
            throws Exception {
        try (var context = context();
             var executor =
                     Executors.newVirtualThreadPerTaskExecutor()) {
            var calculator =
                    context.getBean(StatefulPageCalculator.class);

            var alice = executor.submit(
                    () -> calculator.calculate("alice", 40));
            assertThat(calculator.awaitAliceStored()).isTrue();

            var bob = executor.submit(() -> {
                try {
                    return calculator.calculate("bob", 90);
                } finally {
                    calculator.markBobFinished();
                }
            });

            assertThat(bob.get(5, SECONDS)).isEqualTo(9);
            assertThat(alice.get(5, SECONDS)).isEqualTo(9);
        }
    }

    private static AnnotationConfigApplicationContext context() {
        return new AnnotationConfigApplicationContext(
                CalculatorConfig.class);
    }

    @Configuration(proxyBeanMethods = false)
    static class CalculatorConfig {
        @Bean
        StatefulPageCalculator pageCalculator() {
            return new StatefulPageCalculator();
        }
    }

    static final class StatefulPageCalculator {
        private int lastTotalItems;
        private final CountDownLatch aliceStored =
                new CountDownLatch(1);
        private final CountDownLatch bobFinished =
                new CountDownLatch(1);

        int calculate(String member, int totalItems)
                throws InterruptedException {
            lastTotalItems = totalItems;
            if ("alice".equals(member)) {
                aliceStored.countDown();
                if (!bobFinished.await(5, SECONDS)) {
                    throw new IllegalStateException(
                            "Bob did not finish in time");
                }
            }
            return lastTotalItems / 10;
        }

        boolean awaitAliceStored() throws InterruptedException {
            return aliceStored.await(5, SECONDS);
        }

        void markBobFinished() {
            bobFinished.countDown();
        }
    }
}

package board.application;

import static java.util.concurrent.TimeUnit.SECONDS;
import static org.assertj.core.api.Assertions.assertThat;

import java.util.concurrent.Executors;
import java.util.stream.LongStream;
import org.junit.jupiter.api.Test;

final class StatelessPageCalculatorTest {
    @Test
    void 같은_calculator가_호출별_세_결과를_보존한다()
            throws Exception {
        var calculator = new PageCalculator(
                totalItems -> totalItems / 10);

        try (var executor =
                     Executors.newVirtualThreadPerTaskExecutor()) {
            var tasks = LongStream.rangeClosed(1, 100)
                    .mapToObj(requestId -> executor.submit(
                            () -> calculator.calculate(
                                    requestId,
                                    Math.toIntExact(requestId * 10))))
                    .toList();

            for (int index = 1; index <= 100; index++) {
                var result = tasks.get(index - 1)
                        .get(5, SECONDS);

                assertThat(result.requestId())
                        .isEqualTo(index);
                assertThat(result.totalItems())
                        .isEqualTo(index * 10);
                assertThat(result.totalPages())
                        .isEqualTo(index);
            }
        }
    }

    @FunctionalInterface
    interface PageSizePolicy {
        int totalPages(int totalItems);
    }

    record PageResult(
            long requestId,
            int totalItems,
            int totalPages
    ) {
    }

    static final class PageCalculator {
        private final PageSizePolicy policy;

        PageCalculator(PageSizePolicy policy) {
            this.policy = policy;
        }

        PageResult calculate(long requestId, int totalItems) {
            int totalPages = policy.totalPages(totalItems);
            return new PageResult(
                    requestId, totalItems, totalPages);
        }
    }
}