Ch18 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 context switch?

Answer 2

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 3

What is a thread priority?

Answer 3

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 4

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

Answer 4

None and nothing.

Question 5

What package does the Thread class reside in?

Answer 5

java.lang

Question 6

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

Answer 6

• 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 7

What method is used to start a thread?

Answer 7

start()

Question 8

What exception can Thread.sleep() throw?

Answer 8

InterruptedException.

Question 9

In what package does the Executor class reside in?

Answer 9

java.util.concurrent

Question 10

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

Answer 10

shutdown()

Question 11

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

Answer 11

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

Question 12

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

Answer 12

isTerminated()

Question 13

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

Answer 13

isShutDown()

Question 14

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

Answer 14

shutdownNow()

Question 15

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

Answer 15

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 16

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

Answer 16

execute(runnable)

Question 17

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

Answer 17

submit(runnable)

Question 18

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

Answer 18

submit(callable)

Question 19

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 19

invokeAll(collection)

Question 20

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 20

invokeAny(collection)

Question 21

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

Answer 21

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

Question 22

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

Answer 22

isDone()

Question 23

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

Answer 23

isCancelled()

Question 24

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

Answer 24

cancel()

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

Question 25

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

Answer 25

get()

Question 26

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 26

get(1, TimeUnit.SECONDS)

it will throw a TimeoutException if the timeout was reached.

Question 27

What package does the Callable interface reside in?

Answer 27

java.util.concurrent

Question 28

What is the method signature of the interface Callable?

Answer 28

call()

Question 29

What is the difference between a Runnable and a Callable?

Answer 29

• 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 30

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

Answer 30

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

Question 31

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

Answer 31

shutdown()

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

Question 32

What does the method awaitTermination return?

Answer 32

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

Question 33

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 33

Start
result!
End

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

Question 34

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

Answer 34

ScheduledExecutorService

Question 35

How can we create a new ScheduledExecutorService?

ScheduledExecutorService service = …

Answer 35

ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();

Question 36

What methods does the ScheduledExecutorService have?

Answer 36

• 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 37

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 37

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

Question 38

Which ExecutorService implementations use a thread pool?

Answer 38

• CachedThreadPool
• FixedThreadPool
• ScheduledThreadPool

Question 39

What is the ExecutorService: FixedThreadPool?

Answer 39

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

Question 40

What is the ScheduledExecutorService: ScheduledThreadPool?

Answer 40

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

Question 41

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

Answer 41

ExecutorService service = Executors.newFixedThreadPool(1);

1 thread = same as SingleThreadExecutor.

Question 42

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

Answer 42

Runtime.getRuntime().availableProcessors()

Question 43

What is a race condition?

Answer 43

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

Question 44

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

Answer 44

• AtomicBoolean
• AtomicInteger
• AtomicLong

Question 45

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

private int sheepCount = 0;

Answer 45

replace int by AtomicInteger

private AtomicInteger sheepCount = new AtomicInteger(0);

Question 46

What Java types can be used in a synchronized statement?

Answer 46

Any Object

Question 47

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 47

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

or

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

Question 48

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

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

Answer 48

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

Question 49

What is the Lock implementation class ReentantLock?

Answer 49

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 50

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

Answer 50

It will throw an IllegalMonitorStateException.

Question 51

What methods does the Lock interface contain?

Answer 51

• 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 52

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

Answer 52

• 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 53

What is the CyclicBarrier class?

Answer 53

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 54

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

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

Answer 54

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

Question 55

What is the purpose of concurrent collection classes?

example: ConcurrentHashMap

Answer 55

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 56

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 56

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 57

When should you use concurrent collection classes?

Answer 57

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 58

What is the difference between a Queue and a BlockingQueue?

Answer 58

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

Question 59

What is a LinkedBlockingQueue?

Answer 59

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

Question 60

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

Answer 60

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 61

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 61

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 62

What types of liveness issues exist?

Answer 62

• deadlock
• starvation
• livelock

Question 63

What is deadlock?

Answer 63

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

Question 64

What is starvation?

Answer 64

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 65

What is livelock?

Answer 65

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

Question 66

What are two ways to create a parallel stream?

Answer 66

• calling parallel() on an existing stream.
• calling parallelStream() on a Collection Object.

Question 67

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 67

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 68

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 68

D, F

Question 69

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 69

A, C, D, F.

All methods are capable of throwing unchecked exceptions, so option A is correct. 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.