public class Memoizer<A, V> implements Computable<A, V> {
    private final ConcurrentMap<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
    private final Computable<A, V> c;

    public Memoizer(Computable<A, V> c) {
        this.c = c;
    }

    public V compute(final A arg) throws InterruptedException {
        while (true) {
            Future<V> f = cache.get(arg);
            if (f == null) {
                Callable<V> eval = new Callable<V>() {
                    public V call() throws InterruptedException {
                        return c.compute(arg);
                    }
                };
                FutureTask<V> ft = new FutureTask<V>(eval);
                f = cache.putIfAbsent(arg, ft);
                if (f == null) {
                    f = ft;
                    ft.run();
                }
            }
            try {
                return f.get();
            } catch (CancellationException e) {
                cache.remove(arg, f);
            } catch (ExecutionException e) {
                throw LaunderThrowable.launderThrowable(e.getCause());
            }
        }
    }
}

public class PrintTest {
    static volatile int count = 1;
    public static void printZero() {
        System.out.print("0");
    }
    public static void printOdd() {
        System.out.print(count);
    }
    public static void printEven() {
        System.out.print(count);
    }

    public static void print(int n) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Condition zeroCond = lock.newCondition();
        Condition oddCond = lock.newCondition();
        Condition evenCond = lock.newCondition();

        Thread zero = new Thread(() -> {
            lock.lock();
            while (count <= n) {
                zeroCond.await();
                if (count <= n) {
                    printZero();
                }
                if (count % 2 == 1) {
                    evenCond.signal();
                } else {
                    oddCond.signal();
                }
            }
            lock.unlock();
        });
        Thread odd = new Thread(() -> {
            lock.lock();
            while (count <= n) {
                oddCond.await();
                if (count > n) {
                    return;
                }
                printEven();
                count++;
                zeroCond.signal();
            }
            lock.unlock();
        });

        Thread even = new Thread(() -> {
            lock.lock();
            while (count <= n) {
                evenCond.await();
                if (count > n) {
                    return;
                }
                printOdd();
                count++;
                zeroCond.signal();
            }
            lock.unlock();
        });

        zero.start();
        odd.start();
        even.start();

        lock.lock();
        zeroCond.signal();
        lock.unlock();

        zero.join();
        odd.join();
        even.join();
    }
}