Chapter 18: Concurrency

Question 1

What is a thread?

Answer 1

A thread is the smallest unit of execution that can be scheduled by the operating system.

Question 2

What is a system thread?

Answer 2

A system thread is created by the JVM and runs in the background of the application.

For example: the garbage collection is managed by a system thread that is created by the JVM and runs in the background, helping to free memory that is no longer in use.

Question 3

What is a user-defined thread?

Answer 3

A user-defined thread is one created by the application developer to accomplish a specific task.

Question 4

What is a context switch?

Answer 4

A context switch is the process of storing a thread’s current state and later restoring the state of the thread to continue execution.

Question 5

What is a thread priority?

Answer 5

A thread priority is a numeric value associated with a thread that is taken into consideration by the thread scheduler when determining which threads should currently be executing.

In java, thread priorities are specified as integer values.

Question 6

What arguments does the Runnable interface take? And what does it return?

Answer 6

None and nothing.

Question 7

Is Runnable a functional interface?

Answer 7

yes

Question 8

What is the method signature of the interface Runnable?

Answer 8

run()

Question 9

Does the following code compile?

Runnable sloth = () -> {return;}

Answer 9

The Runnable interface has one abstract method: run(), which takes no arguments and returns void. Therefore, this code is valid.

Question 10

Does the following code compile?

Runnable sloth = () -> 5;

Answer 10

No. It returns 5 while a Runnable cannot return a value.

Question 11

Does the following code compile?

Runnable sloth = () -> System.out.println(“Hello World”);

Answer 11

Yes.

Question 12

What package does the Thread class reside in?

Answer 12

java.lang

Question 13

Is order of thread execution guaranteed?

Answer 13

Order of thread execution is never guaranteed. It may be executed immediately or delayed for a significant amount of time.

Question 14

What are two ways to define a task that a Thread instance will execute?

Answer 14

• Providing a Runnable object or lamda expression to the Thread constructor: new Thread(runnable);
• Create a class that extends Thread and overrides the run() method.

Question 15

What method is used to start a thread?

Answer 15

start()

Question 16

What is polling?

Answer 16

Polling is the process of intermittently checking data at some fixed interval.

Example: checking to see if a counter variable has reached 100 in a while loop, while another thread is incrementing it.

Question 17

What exception can Thread.sleep() throw?

Answer 17

InterruptedException.

Question 18

In what package does the Executor class reside in?

Answer 18

java.util.concurrent

Question 19

Is order of thread execution with a single-thread executor guaranteed?

Answer 19

Yes, because it can only perform 1 task at a time.

Question 20

What method should be called once you have finished using a thread executor?

Answer 20

shutdown()

Question 21

What does the executor’s shutdown() method do?

Answer 21

Rejects any new task submitted to the thread executor while continuing to execute any previously submitted tasks.

Question 22

What method can we call to check if shutdown() was called and the thread executor has completed all active tasks?

Answer 22

isTerminated()

Question 23

What method can we call to check if shutdown() was called on a thread executor?

Answer 23

isShutDown()

Question 24

What method can we call on a thread executor to attempt to cancel all running and upcoming tasks?

Answer 24

shutdownNow()

Question 25

What does the thread executor method shutdownNow() do and return?

Answer 25

It will attempt to cancel all running and discard all upcoming tasks, and return a List of all tasks that were submitted but never started.

Question 26

What thread executor method is available to execute a Runnable and return void? (fire-and-forget)

Answer 26

execute(runnable)

Question 27

What thread executor method is available to execute a Runnable and return a Future to determine wether the task is complete?

Answer 27

submit(runnable)

Question 28

What thread executor method is available to execute a Callable and return a Future to determine wether the task is complete?

Answer 28

submit(callable)

Question 29

What thread executor method is available to execute a list of tasks and waits for all tasks to be complete and returns a list of Future instances?

Answer 29

invokeAll(collection)

Question 30

What thread executor method is available to execute a list of tasks and waits for any of the tasks to be complete and returns a Future instance of that task?

Answer 30

invokeAny(collection)

Question 31

What is the advantage of using submit() over execute()?

Answer 31

submit() is equal to execute() except that it has a return object that can be used to track the result.

Question 32

What Future method is available to check to see if the task was completed?

Answer 32

isDone()

Question 33

What Future method is available to check to see if the task was cancelled?

Answer 33

isCancelled()

Question 34

What Future method is available to attempt to cancel a a task? What does it return?

Answer 34

cancel()

Returns true if cancelling was succesful or false if the task could not be cancelled or was completed.

Question 35

What Future method is available to get the result of a task, while waiting until it is available?

Answer 35

get()

Question 36

What Future method is available to get the result of a task, with a timeout of 1 second? What happends when the timeout is reached?

Answer 36

get(1, TimeUnit.SECONDS)

it will throw a TimeoutException if the timeout was reached.

Question 37

Is Callable a functional interface?

Answer 37

Yes.

Question 38

What package does the Callable interface reside in?

Answer 38

java.util.concurrent

Question 39

What is the method signature of the interface Callable?

Answer 39

call()

Question 40

What is the difference between a Runnable and a Callable?

Answer 40

• Runnable has a run() method, Callable has a call() method.
• run() returns void, while call() returns a generic object.
• call() can throw a checked exception.

Question 41

How can we wait for all tasks to finish in an executor?

Answer 41

using the awaitTermination(long timeout, TimeUnit unit) method.

Question 42

What method should be called first before calling awaitTermination(long timeout, TimeUnit unit)? why?

Answer 42

shutdown()

If awaitTermination() is called before shutdown() within the same thread, that thread will wait the full timeout value sent with awaitTermination()

Question 43

What does the method awaitTermination return?

Answer 43

It returns true if this executor terminated and false if the timeout elapsed before termination

Question 44

invokeAll() and invokeAny() are synchronized/asynchonized

Answer 44

synchonized.

Meaning the JVM will wait until the results are available before returning control to the enclosing program.

Question 45

Given the following code, in what order are the results printed?

ExecutorService service = null;
        try {
            System.out.println("Start");
            service = Executors.newSingleThreadExecutor();
            Callable c = () -> "result!";
            Future result = service.submit(c);
            System.out.println(result.get());
            System.out.println("End");
        } finally {
            if (service != null) service.shutdown();
        }

Answer 45

Start
result!
End

The get() method waits endlessly until the result is available, thus always printing ‘result!’ before ‘End’.

Question 46

What do the invokeAll() and invokeAny() methods take as a parameter?

Answer 46

A collection of tasks.

Question 47

What interface can be used to schedule tasks at some future time or at an interval?

Answer 47

ScheduledExecutorService

Question 48

How can we create a new ScheduledExecutorService?

ScheduledExecutorService service = …

Answer 48

ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();

Question 49

What methods does the ScheduledExecutorService have?

Answer 49

• schedule(Callable, long delay, TimeUnit)
  schedules and executes a Callable task after the given delay
• schedule(Runnable, long delay, TimeUnit)
  schedules and executes a Runnable task after the given delay
• scheduleAtFixedRate(Runnable, long initialDelay, long period, TimeUnit)
  Creates and executes a Runnable task after the given initial delay, creating a new task every period value that passes.
• scheduleWithFixedDelay(Runnable, long initialDelay, long delay, TimeUnit)
  Creates and executes a Runnable task after the given initial delay and subsequently with the given delay between the termination of one execution and the commencement of the next.

Question 50

Complete the following code to execute the task after 10 minutes.

ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
Runnable task = () -> System.out.println("Hello World");
ScheduledFuture> result = ...

Answer 50

service.schedule(task, 10, TImeUnit.MINUTES);

Question 51

What is the difference between scheduleAtFixedRate() and scheduleWithFixedDelay()

Answer 51

scheduleAtFixedRate() will run tasks repeatedly at specific intervals, without waiting for the previous task to finish. example -> A task need to run every 2 minutes.

scheduleWithFixedDelay() will wait for the previous task to be completed and wait an amount of time after that before repeating the execution. example -> A task need to run 2 minutes after completing the previous task.

Question 52

What is a thread pool?

Answer 52

A thread pool is a group of pre-instantiated reusable threads that are available to perform a set of arbitrary tasks.

Question 53

Which ExecutorService implementations use a thread pool?

Answer 53

• CachedThreadPool
• FixedThreadPool
• ScheduledThreadPool

Question 54

What is the ExecutorService: CachedThreadPool?

Answer 54

An ExecutorService that creates a thread pool that creates new threads as needed but will reuse previously constructed threads when they are available.

Question 55

What is the ExecutorService: FixedThreadPool?

Answer 55

An ExecutorService that creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.

Question 56

What is the ScheduledExecutorService: ScheduledThreadPool?

Answer 56

A ScheduledExecutorService that creates a thread pool that can schedule commands to run after a given delay or to execute periodically.

Question 57

Create a FixedThreadPool such that it behaves similarly to a SingleThreadExecutor.

Answer 57

ExecutorService service = Executors.newFixedThreadPool(1);

1 thread = same as SingleThreadExecutor.

Question 58

What command is often used to determine the appropriate pool size?

Answer 58

Runtime.getRuntime().availableProcessors()

Question 59

What is a race condition?

Answer 59

The unexpected result of two tasks executing at the same time.

Question 60

What atomic classes are available, such that reading and updating the value is thread-safe?

Answer 60

• AtomicBoolean
• AtomicInteger
• AtomicLong

Question 61

How can we make the following variable thread-safe such that it won’t produce a race condition?

private int sheepCount = 0;

Answer 61

replace int by AtomicInteger

private AtomicInteger sheepCount = new AtomicInteger(0);

Question 62

What is mutual exclusion?

Answer 62

the property that at most one thread is executing a particular segment of code at a given time.

Question 63

What does the synchronized block do?

Answer 63

Each thread that arrives at the code block will first check if any threads are in the block. Only one thread can acquire the lock and execute the code block at a time.

Question 64

Given the following code, how can we ensure that the tasks will execute in order? (1 thread at a time).

...
private void incrementAndReport() {
   System.out.println((++sheepCount)+ "");
}
...

// using fixed thread pool with 20 threads.
for(int i = 0; i < 10; i++) {
    service.submit(() -> manager.incrementAndReport());
}

Answer 64

private void incrementAndReport() {
    synchronized(this) {
        System.out.println((++sheepCount)+ "");
    }
}

or

private synchronized void incrementAndReport() {
System.out.println((++sheepCount)+ “”);
}

Question 65

What Java types can be used in a synchronized statement?

Answer 65

Any Object

Question 66

Would the following code work in a thread-safe manner?

...
private Object someObj = new Object();
private void incrementAndReport() {
    synchronized(someObj) {
        System.out.println((++sheepCount)+ "");
    }
}
...

Answer 66

yes. We can synchronize on any object, as long as it is the same object.

Question 67

Given the class Test and using the following code, how can we apply synchronization on a static method?

public static void printDaysOfWork() {
System.out.print(“test”);
}

Answer 67

public static void printDaysOfWork() {
    synchronized(Test.class) {
        System.out.print("test");
    }
}

or

public static synchronized void printDaysOfWork() {
System.out.print(“test”);
}

Question 68

What is the equivalent of the following code, using the Lock interface?

Object object = new Object();
synchronized(object) {
    // code
}

Answer 68

Lock lock = new ReentrantLock();
try {
    lock.lock();
    // code
} finally {
    lock.unlock();
}

Question 69

What is the Lock implementation class ReentantLock?

Answer 69

The ReentrantLock class ensures that once a thread has called lock() and obtained the lock, all other threads that call lock() must wait until the first thread calls unlock().

Question 70

What happens when you want to release a lock (lock.unlock()) that no thread has?

Answer 70

It will throw an IllegalMonitorStateException.

Question 71

What methods does the Lock interface contain?

Answer 71

• void lock()
  requests a lock and blocks until lock is acquired
• void unlock()
  releases a lock
• boolean tryLock()
  requests a lock and returns immediately. Returns a boolean indicating wether the lock was successfully acquired.
• boolean tryLock(long, TimeUnit)
  requests a lock and blocks up to the specified time until lock is required. Returns a boolean indicating wether the lock was successfully acquired.

Question 72

What is the problem with the following code?

Lock lock = new ReentrantLock();
if(lock.tryLock()) {
    try {
        lock.lock();
    } finally {
        lock.unlock();
    }
}

Answer 72

The thread obtains the lock twice but releases it only once. That means no new thread would be able to acquire the lock until the second one has been unlocked too.

Question 73

The ReentrantLock class supports the same features as the synchronized block. What improvements are added?

Answer 73

• Ability to request a lock without blocking
• Ability to request a lock while blocking for a specified amound of time.
• A lock can be created with a fairness property, in which the lock is granted to threads in the order it was requested.

Question 74

What is the CyclicBarrier class?

Answer 74

The CyclicBarrier class takes in its constructors a limit value, indicating the number of threads to wait for. As each thread finishes it calls the await() method on the cyclic barrier. Once the specified number of threads have each called await(), the barrier is released and all threads can continue.

Question 75

given the following method, add the use of CyclicBarrier such that all threads wait after removing all lions.

performTasks() {
removeLions();
cleanPen();
}

Answer 75

performTasks(CyclicBarrier c) {
    try {
        removeLions();
        c.await();
        cleanPen();
    } catch(InterruptedException | BrokenBarrierException)    { }
}

Question 76

What is the purpose of concurrent collection classes?

example: ConcurrentHashMap

Answer 76

to solve common memory consistency errors. A memory consistency error occurs when two threads have inconsistent views of what should be the same data.

Question 77

Why is the following code problematic? And how do we solve it?

var foodData = new HashMap();
foodData.put("penguin", 1);
foodData.put("flamingo", 2);
for (String key : foodData.keySet()){
    foodData.remove(key);
}

Answer 77

This code will throw a ConcurrentModificationException during the second iteration of the loop, since the iterator on keySet() is not properly updated after the first element is removed.

Changing the first line to ConcurrentHashMap() will prevent the code from throwing an exception at runtime.

Question 78

When should you use concurrent collection classes?

Answer 78

Anytime that you are going to have multiple threads modify a collections object outside a synchronized block or method (even if you don’t expect a concurrency problem).

Question 79

What type of objects can be accessed by multiple threads without ever having a concurrency problem?

Answer 79

immutable or read-only objects.

Question 80

What is the difference between a Queue and a BlockingQueue?

Answer 80

The BlockingQueue is a regular Queue that includes methods that will wait a specific amount of time to complete an operation.

Question 81

What is a LinkedBlockingQueue?

Answer 81

A LinkedBlockingQueue is an implementation of the BlockingQueue interface, which maintains a linked list between its elements.

Question 82

How can you obtain a synchronized collection if you’re not working with a concurrent collection class (such as ConcurrentHashMap)?

Answer 82

The Concurreny API includes methods for obtaining synchronized versions of existing nonconcurrent collection objects. These are defined in the Collections class.

example:

• synchronizedCollection(Collection c)
• synchronizedList(List list)
• synchronizedSet(Set s)
• …

Question 83

Does the following code produce an exception?

var foodData = new HashMap();
foodData.put("penguin", 1);
foodData.put("flamingo", 2);
var synFoodData = Collections.synchronizedMap(foodData);
for (String key : synFoodData.keySet()){
    foodData.remove(key);
}

Answer 83

Yes. This will still throw a ConcurrentModificationException, despite using a synchronized version of foodData.

Other than iterating over the collection, the object returned by Collections.synchronized…() are safe from memory consistency errors and can be used among multiple threads.

Question 84

What is liveness?

Answer 84

Liveness is the ability of an application to be able to execute in a timely manner.

Question 85

What types of liveness issues exist?

Answer 85

• deadlock
• starvation
• livelock

Question 86

What is deadlock?

Answer 86

Deadlock occurs when two or more threads are blocked forever, each waiting on the other.

Question 87

What is starvation?

Answer 87

Starvation occurs when a single thread is perpetually denied access to a shared resource or lock. The thread is still active but unable to complete its work as a result of other threads constantly taking the resource that they are trying to access.

Question 88

What is livelock?

Answer 88

Livelock occurs when two or more threads are conceptually blocked forever, although they are each still active and trying to complete their task.

Question 89

What are two ways to create a parallel stream?

Answer 89

• calling parallel() on an existing stream.

- calling parallelStream() on a Collection Object.

Question 90

Will the following code compile?

public static void main(String[] args) {
    ExecutorService service = null;
    try {
        service = Executors.newFixedThreadPool(2);
        var manager = new LionPenManager();

        var c1 = new CyclicBarrier(4); 
        var c2 = new CyclicBarrier (4, () ->     
            System.out.println("*** Pen Cleaned!"));

   for (int i= 0; 14; i++) {
       service.submit(() -> manager.performTask(c1, c2)); 

       } finally {
           if (service 1= null) { 
               service.shutdown();
           }
       }
}

Answer 90

Yes, but this will result in a deadlock because the number of threads will never reach the cyclicBarrier required number (4) to continue execution

Question 91

Given an instance of a Stream s and a Collection c, which are valid ways of creating a parallel stream? (Choose all that apply.)

A. new ParallelStream(s)
B. c.parallel()
C. s.parallelStream()
D. c.parallelStream()
E. new ParallelStream(c)
F. s.parallel()

Answer 91

D, F

Question 92

Which of the following statements about the Callable call() and Runnable run() methods are correct? (Choose all that apply.)

A. Both can throw unchecked exceptions.
B. Callable takes a generic method argument.
C. Callable can throw a checked exception.
D. Both can be implemented with lambda expressions.
E. Runnable returns a generic type.
F. Callable returns a generic type.
G. Both methods return void.

Answer 92

A, C, D, F.

All methods are capable of throwing unchecked exceptions, so option A is cor rect. Runnable and Callable statements both do not take any arguments, so option B is incorrect. Only Callable is capable of throwing checked exceptions, so option C is also correct. Both Runnable and Callable are functional interfaces that can be implemented with a lambda expression, so option D is also correct. Finally, Runnable returns void and Callable returns a generic type, making option F correct and making options E and G incorrect.