Threads - Finding the output Questions and Answers

Sample41 is run - what will be the output?

public class Sample41
{
    static final StringBuilder LOG = new StringBuilder();

    public static void main(String[] args) throws InterruptedException
    {
        Runnable job = () -> { for (int i = 0; i < 1000; i++) LOG.append('x'); };
        Thread a = new Thread(job), b = new Thread(job);
        a.start(); b.start(); a.join(); b.join();
        System.out.println(LOG.length());
    }
}

Sample42 is run - what will be the output?

public class Sample42 extends Thread
{
    static final StringBuffer SINK = new StringBuffer();

    public void run()
    {
        int written = 0;
        while (written < 750)
        {
            SINK.append('.');
            written++;
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        Sample42 p = new Sample42(), q = new Sample42();
        p.start(); q.start();
        p.join(); q.join();
        System.out.println(SINK.length());
    }
}

Sample43 is run - what will be the output?

import java.util.*;

public class Sample43
{
    static final Map<Integer, Integer> MAP = new HashMap<>();

    public static void main(String[] args) throws InterruptedException
    {
        Runnable job = () -> { for (int i = 0; i < 1000; i++) MAP.put(i, i); };
        Thread a = new Thread(job), b = new Thread(job);
        a.start(); b.start(); a.join(); b.join();
        System.out.println(MAP.size());
    }
}

Sample44 is run - what will be the output?

import java.util.concurrent.*;

public class Sample44
{
    static final ConcurrentMap<String, String> CACHE = new ConcurrentHashMap<>();

    static class Filler implements Runnable
    {
        public void run()
        {
            for (int i = 0; i < 400; i++)
            {
                CACHE.put("key" + i, "value");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        Thread one = new Thread(new Filler()), two = new Thread(new Filler());
        one.start(); two.start();
        one.join(); two.join();
        System.out.println(CACHE.keySet().size());
    }
}

Sample45 is run - what will be the output?

public class Sample45
{
    public static void main(String[] args) throws InterruptedException
    {
        final Object gate = new Object();
        Thread waiter = new Thread(() ->
        {
            synchronized (gate)
            {
                try { gate.wait(); }
                catch (InterruptedException e) { System.out.println("interrupted"); }
            }
        });
        waiter.start();
        Thread.sleep(100);
        waiter.interrupt();
        waiter.join();
    }
}

Sample46 is run - what will be the output?

public class Sample46
{
    static volatile boolean running = true;

    public static void main(String[] args) throws InterruptedException
    {
        Thread worker = new Thread(() ->
        {
            while (running) { }
            System.out.println("stopped");
        });
        worker.start();
        Thread.sleep(100);
        running = false;
        worker.join();
    }
}

Sample47 is run - what will be the output?

public class Sample47 extends Thread
{
    private boolean entered;

    public void run()
    {
        entered = true;
        System.out.println("body");
    }

    public static void main(String[] args) throws InterruptedException
    {
        Sample47 task = new Sample47();
        task.join();
        System.out.println("after " + task.entered);
    }
}

Sample48 is run - what will be the output?

public class Sample48
{
    public static void main(String[] args) throws InterruptedException
    {
        Thread reporter = new Thread(new Runnable()
        {
            public void run() { System.out.print("work "); }
        });
        reporter.start();
        for (int attempt = 0; attempt < 3; attempt++)
        {
            reporter.join();
        }
        System.out.print("done");
    }
}

Sample49 is run - what will be the output?

public class Sample49
{
    public static void main(String[] args) throws InterruptedException
    {
        Thread t = new Thread(() ->
        {
            try { Thread.sleep(1000); System.out.println("slept"); }
            catch (InterruptedException e) { System.out.println("cut short"); }
        });
        t.interrupt();
        t.start();
        t.join();
    }
}

Sample50 is run - what will be the output?

public class Sample50
{
    public static void main(String[] args) throws InterruptedException
    {
        Thread t = new Thread(() ->
        {
            long n = 0;
            while (!Thread.currentThread().isInterrupted()) n++;
            System.out.println("noticed");
        });
        t.start();
        Thread.sleep(50);
        t.interrupt();
        t.join();
    }
}