Threads - Finding the output Questions and Answers

Sample51 is run - what will be the output?

import java.util.concurrent.*;

public class Sample51
{
    public static void main(String[] args) throws Exception
    {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        Future<Integer> f = pool.submit(() -> 7 / 0);
        try { System.out.println(f.get()); }
        catch (ExecutionException e)
        { System.out.println("failed: " + e.getCause().getClass().getSimpleName()); }
        pool.shutdown();
    }
}

Sample52 is run - what will be the output?

import java.util.concurrent.*;

public class Sample52
{
    public static void main(String[] args) throws Exception
    {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Future<?> f = pool.submit(() -> System.out.print("ran "));
        System.out.print(f.get() + " ");
        pool.shutdown();
        System.out.print(pool.isShutdown());
    }
}

Sample53 is run - what will be the output?

import java.util.concurrent.*;

public class Sample53
{
    public static void main(String[] args) throws Exception
    {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        pool.submit(() ->
        {
            try { Thread.sleep(5000); }
            catch (InterruptedException e) { System.out.println("stopped early"); }
        });
        Thread.sleep(100);
        pool.shutdownNow();
    }
}

Sample54 is run - what will be the output?

public class Sample54 extends Thread
{
    public void run()
    {
        try
        {
            Thread.sleep(5000);
        }
        catch (InterruptedException ignored)
        {
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        Sample54 sleeper = new Sample54();
        sleeper.start();
        Thread.sleep(200);
        Thread.State observed = sleeper.getState();
        sleeper.interrupt();
        System.out.println(observed);
    }
}

Sample55 is run - what will be the output?

public class Sample55
{
    static final Object GATE = new Object();

    public static void main(String[] args) throws InterruptedException
    {
        Thread t = new Thread(() ->
        {
            synchronized (GATE)
            {
                try { GATE.wait(); } catch (InterruptedException e) { }
            }
        });
        t.start();
        Thread.sleep(200);
        System.out.println(t.getState());
        synchronized (GATE) { GATE.notifyAll(); }
    }
}

Sample56 is run - what will be the output?

public class Sample56
{
    public static void main(String[] args) throws InterruptedException
    {
        final Object lock = new Object();
        Thread holder = new Thread(() ->
        {
            synchronized (lock)
            {
                try { Thread.sleep(3000); } catch (InterruptedException e) { }
            }
        });
        holder.start();
        Thread.sleep(100);
        Thread waiter = new Thread(() -> { synchronized (lock) { } });
        waiter.start();
        Thread.sleep(100);
        System.out.println(waiter.getState());
        holder.interrupt();
    }
}

Sample57 is run - what will be the output?

public class Sample57
{
    public static void main(String[] args)
    {
        System.out.print(Thread.currentThread().isDaemon() + " ");
        System.out.print(new Thread().isDaemon());
    }
}

Sample58 is run - what will be the output?

public class Sample58
{
    public static void main(String[] args) throws InterruptedException
    {
        Thread outer = new Thread(() ->
        {
            Thread inner = new Thread(() -> { });
            System.out.println(inner.isDaemon());
        });
        outer.setDaemon(true);
        outer.start();
        outer.join();
    }
}

Sample59 is run - what will be the output?

public class Sample59
{
    public static void main(String[] args) throws InterruptedException
    {
        final Object gate = new Object();
        long start = System.currentTimeMillis();
        synchronized (gate) { gate.wait(300); }
        System.out.println(System.currentTimeMillis() - start >= 300);
    }
}

Sample60 is run - what will be the output?

public class Sample60
{
    static final Object GATE = new Object();

    public static void main(String[] args)
    {
        synchronized (GATE) { GATE.notifyAll(); }
        System.out.println("sent");
    }
}