Threads - Finding the output Questions and Answers

Sample21 is run - what will be the output?

public class Sample21
{
    static int tally = 0;
    static final Object LOCK = new Object();

    public static void main(String[] args) throws InterruptedException
    {
        Runnable job = () ->
        {
            for (int i = 0; i < 2000; i++)
            {
                synchronized (LOCK) { tally++; }
            }
        };
        Thread p = new Thread(job), q = new Thread(job);
        p.start(); q.start();
        p.join(); q.join();
        System.out.println(tally);
    }
}

Sample22 is run - what will be the output?

public class Sample22
{
    public static void main(String[] args)
    {
        Thread sweeper = new Thread(() ->
        {
            while (true) { }
        });
        sweeper.setDaemon(true);
        sweeper.start();
        System.out.println("main ends");
    }
}

Sample23 is run - what will be the output?

public class Sample23 extends Thread
{
    public void run()
    {
        System.out.print("swept ");
    }

    public static void main(String[] args) throws InterruptedException
    {
        Sample23 sweeper = new Sample23();
        sweeper.setDaemon(true);
        sweeper.start();
        sweeper.join();
        System.out.print("exit");
    }
}

Sample24 is run - what will be the output?

public class Sample24 implements Runnable
{
    public void run() throws InterruptedException
    {
        Thread.sleep(100);
    }

    public static void main(String[] args)
    {
        new Thread(new Sample24()).start();
    }
}

Sample25 is run - what will be the output?

public class Sample25
{
    public static void main(String[] args)
    {
        Runnable r = () -> System.out.println("go");
        r.start();
    }
}

Sample26 is run - what will be the output?

public class Sample26 extends Thread
{
    private final String label = "report";
    private int calls;

    public void run(String prefix)
    {
        calls++;
        System.out.println(prefix + label + calls);
    }

    public static void main(String[] args) throws InterruptedException
    {
        Sample26 task = new Sample26();
        task.start();
        task.join();
        System.out.println("finished " + task.calls);
    }
}

Sample27 is run - what will be the output?

public class Sample27
{
    public static void main(String[] args) throws InterruptedException
    {
        Object lock = new Object();
        Thread t = new Thread(() ->
        {
            synchronized (lock)
            {
                System.out.println("worker");
                lock.notify();
            }
        });
        synchronized (lock)
        {
            t.start();
            lock.wait();
            System.out.println("main");
        }
    }
}

Sample28 is run - what will be the output?

public class Sample28 extends Thread
{
    static final Object GATE = new Object();

    public void run()
    {
        synchronized (GATE)
        {
            GATE.notifyAll();
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        Sample28 signaller = new Sample28();
        signaller.start();
        signaller.join();

        synchronized (GATE)
        {
            GATE.wait();
        }
        System.out.println("woken");
    }
}

Sample29 is run - what will be the output?

public class Sample29
{
    static boolean ready = false;

    public static void main(String[] args) throws InterruptedException
    {
        Object lock = new Object();
        new Thread(() ->
        {
            synchronized (lock) { ready = true; lock.notifyAll(); }
        }).start();
        synchronized (lock)
        {
            while (!ready) lock.wait();
        }
        System.out.println("ready");
    }
}

Sample30 is run - what will be the output?

import java.util.concurrent.atomic.AtomicInteger;

public class Sample30
{
    static AtomicInteger count = new AtomicInteger();

    public static void main(String[] args) throws InterruptedException
    {
        Runnable r = () -> { for (int i = 0; i < 10000; i++) count.incrementAndGet(); };
        Thread a = new Thread(r), b = new Thread(r);
        a.start(); b.start();
        a.join(); b.join();
        System.out.println(count.get());
    }
}