You are asked to investigate a bug in an application that uses the following class. This is used by two threads, which record the time at which the code last saw specific galaxy types.

import java.time.Instant;
List<Galaxy> galaxies = FakeGalaxyListFactory.make(10000);
ConcurrentHashMap<Galaxy.GalaxyType, Instant> galaxyTypesSeen = new ConcurrentHashMap<>();
CountDownLatch latch = new CountDownLatch(galaxies.size());

Thread galaxyScanner = new Thread(
        () -> {
            galaxies.forEach(
                galaxy -> {
                    galaxyTypesSeen.put(
                    galaxy.galaxyType, Instant.now());
                    latch.countDown();
                }
            );
        });

;

Thread galaxyHistoryReporter = new Thread(
        () -> {
            try {
                // Wait for the latch to reach 0
                while (latch.getCount() != 0) {
                    Iterator<Galaxy.GalaxyType> iterator =
                            galaxyTypesSeen.keySet().iterator();
                    // Loop over the keyset
                    while (iterator.hasNext()) {
                        Galaxy.GalaxyType galaxyType = iterator.next();
                        Instant lastSeen = galaxyTypesSeen.get(galaxyType);
                        String report = String.format("galaxyType:%s", lastSeen);
                        System.out.println(report);
                    }
                
                    // Pause for .1 seconds or until our latch reaches 0
                    latch.await(1, TimeUnit.NANOSECONDS);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

When these threads are started, you see ConcurrentModificationExceptions. You can reproduce this by pasting the code into into JShell, and starting it as follows.

jshell> galaxyHistoryReporter.start()
jshell> galaxyScanner.start();
java.util.ConcurrentModificationException
    at java.base/java.util.HashMap$HashIterator.nextNode(HashMap.java:1490)
    at java.base/java.util.HashMap$KeyIterator.next(HashMap.java:1513)
    at REPL.$JShell$39.lambda$do_it$$0($JShell$39.java:16)
    at java.base/java.lang.Thread.run(Thread.java:835)

Which of the following will fix this? 

Look at this code which will add the galaxy names to a new ArrayList. While one thread does this, another will keep reporting on the most recent galaxy seen in that list.  

import java.time.Instant;
List<Galaxy> galaxies = FakeGalaxyListFactory.make(10);
CountDownLatch latch = new CountDownLatch(galaxies.size());
List<String> listOfNames = new ArrayList<>();

Executors.newSingleThreadExecutor().submit(
    ()->{
        galaxies.forEach(
            (galaxy) -> {
                try {
                    // Simulate a possible delay of 1 second
                    Thread.sleep(1000);
                    listOfNames.add(galaxy.name);
                    latch.countDown();
                } catch (Exception e) {
                    e.printStackTrace(); // Todo: handle exception
                } finally {
                    latch.countDown();
                }
            }
        );
    }
);

Executors.newSingleThreadExecutor().submit(
    ()->{
        while( latch.getCount() != 0 ) {
            try {
                Iterator<String> iterator = listOfNames.iterator();
                String galaxy = null;
                System.out.println(Instant.now());
                while (iterator.hasNext()) {
                    // Simulate delay of 1/10th second
                    Thread.sleep(100);
                    // skip ahead
                    galaxy = iterator.next();
                }
                System.out.println("The most recent galaxy seen at this time is " + galaxy);
                latch.await(100, TimeUnit.NANOSECONDS);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
);

When run, this produces output similar to:

java.util.ConcurrentModificationException
    at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1042)
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:996)
    at REPL.$JShell$120.lambda$do_it$$0($JShell$120.java:20)
    at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515)
    at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
    at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
    at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
    at java.base/java.lang.Thread.run(Thread.java:835)
The most recent galaxy seen at this time is Galaxy-6
java.util.ConcurrentModificationException
    at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1042)
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:996)
    at REPL.$JShell$120.lambda$do_it$$0($JShell$120.java:20)
    at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515)
    at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
    at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
    at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
    at java.base/java.lang.Thread.run(Thread.java:835)
The most recent galaxy seen at this time is Galaxy-7
java.util.ConcurrentModificationException
    at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1042)
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:996)
    at REPL.$JShell$120.lambda$do_it$$0($JShell$120.java:20)
    at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515)
    at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
    at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
    at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
    at java.base/java.lang.Thread.run(Thread.java:835)

You can try this out for yourself in JShell.

Which of the following fixes the above issue?

You've been asked by a colleague to help in understanding some code. You're shown a producer class that publishes galaxies to a queue. Feel free to paste it into JShell.

public class GalaxyPublisher {
    BlockingQueue<Galaxy> galaxyQueue;
    
    public GalaxyPublisher (BlockingQueue<Galaxy> galaxyQueue) {
        this.galaxyQueue = galaxyQueue;
    }
    
    public void publish(List<Galaxy> galaxies) {
        galaxies.forEach(galaxy -> {
            try {
                galaxyQueue.put(galaxy);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }
}

What will the following code do when the GalaxyTypeQueue feeding consumer has a depth of 3 or more?

public class Consumer implements Runnable {
    BlockingQueue<Galaxy> galaxyQueue;
    CountDownLatch killSwitch;
    
    public Consumer(BlockingQueue<Galaxy> galaxyQueue, CountDownLatch killSwitch) {
        this.galaxyQueue = galaxyQueue;
        this.killSwitch = killSwitch;
    }
    
    public void run() {
        while (true && killSwitch.getCount() != 0) {
            try {
                Galaxy galaxy = galaxyQueue.take();
                System.out.println("Consumed:" + galaxy.name);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Feel free to try it out in JShell.

Which of the following will result in the consumer receiving 2000 galaxy objects?