Chapter 18: Concurrency Flashcards
1
Q
What is a thread?
A
A thread is the smallest unit of execution that can be scheduled by the operating system.
2
Q
What is a system thread?
A
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.
3
Q
What is a user-defined thread?
A
A user-defined thread is one created by the application developer to accomplish a specific task.
4
Q
What is a context switch?
A
A context switch is the process of storing a thread’s current state and later restoring the state of the thread to continue execution.
5
Q
What is a thread priority?
A
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.
6
Q
What arguments does the Runnable interface take? And what does it return?
A
None and nothing.
7
Q
Is Runnable a functional interface?
A
yes
8
Q
What is the method signature of the interface Runnable?
A
run()
9
Q
Does the following code compile?
Runnable sloth = () -> {return;}
A
The Runnable interface has one abstract method: run(), which takes no arguments and returns void. Therefore, this code is valid.
10
Q
Does the following code compile?
Runnable sloth = () -> 5;
A
No. It returns 5 while a Runnable cannot return a value.
11
Q
Does the following code compile?
Runnable sloth = () -> System.out.println(“Hello World”);
A
Yes.
12
Q
What package does the Thread class reside in?
A
java.lang
13
Q
Is order of thread execution guaranteed?
A
Order of thread execution is never guaranteed. It may be executed immediately or delayed for a significant amount of time.
14
Q
What are two ways to define a task that a Thread instance will execute?
A
- 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.
15
Q
What method is used to start a thread?
A
start()
16
Q
What is polling?
A
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.
17
Q
What exception can Thread.sleep() throw?
A
InterruptedException.
18
Q
In what package does the Executor class reside in?
A
java.util.concurrent
19
Q
Is order of thread execution with a single-thread executor guaranteed?
A
Yes, because it can only perform 1 task at a time.
20
Q
What method should be called once you have finished using a thread executor?
A
shutdown()
21
Q
What does the executor’s shutdown() method do?
A
Rejects any new task submitted to the thread executor while continuing to execute any previously submitted tasks.
22
Q
What method can we call to check if shutdown() was called and the thread executor has completed all active tasks?
A
isTerminated()
23
Q
What method can we call to check if shutdown() was called on a thread executor?
A
isShutDown()
24
Q
What method can we call on a thread executor to attempt to cancel all running and upcoming tasks?
A
shutdownNow()
25
What does the thread executor method shutdownNow() do and return?
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.
26
What thread executor method is available to execute a Runnable and return void? (fire-and-forget)
execute(runnable)
27
What thread executor method is available to execute a Runnable and return a Future to determine wether the task is complete?
submit(runnable)
28
What thread executor method is available to execute a Callable and return a Future to determine wether the task is complete?
submit(callable)
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?
invokeAll(collection)
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?
invokeAny(collection)
31
What is the advantage of using submit() over execute()?
submit() is equal to execute() except that it has a return object that can be used to track the result.
32
What Future method is available to check to see if the task was completed?
isDone()
33
What Future method is available to check to see if the task was cancelled?
isCancelled()
34
What Future method is available to attempt to cancel a a task? What does it return?
cancel()
Returns true if cancelling was succesful or false if the task could not be cancelled or was completed.
35
What Future method is available to get the result of a task, while waiting until it is available?
get()
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?
get(1, TimeUnit.SECONDS)
it will throw a TimeoutException if the timeout was reached.
37
Is Callable a functional interface?
Yes.
38
What package does the Callable interface reside in?
java.util.concurrent
39
What is the method signature of the interface Callable?
call()
40
What is the difference between a Runnable and a Callable?
- 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.
41
How can we wait for all tasks to finish in an executor?
using the awaitTermination(long timeout, TimeUnit unit) method.
42
What method should be called first before calling awaitTermination(long timeout, TimeUnit unit)? why?
shutdown()
If awaitTermination() is called before shutdown() within the same thread, that thread will wait the full timeout value sent with awaitTermination()
43
What does the method awaitTermination return?
It returns true if this executor terminated and false if the timeout elapsed before termination
44
invokeAll() and invokeAny() are synchronized/asynchonized
synchonized.
Meaning the JVM will wait until the results are available before returning control to the enclosing program.
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();
}
```
Start
result!
End
The get() method waits endlessly until the result is available, thus always printing 'result!' before 'End'.
46
What do the invokeAll() and invokeAny() methods take as a parameter?
A collection of tasks.
47
What interface can be used to schedule tasks at some future time or at an interval?
ScheduledExecutorService
48
How can we create a new ScheduledExecutorService?
ScheduledExecutorService service = ...
ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
49
What methods does the ScheduledExecutorService have?
- 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.
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 = ...
```
service.schedule(task, 10, TImeUnit.MINUTES);
51
What is the difference between scheduleAtFixedRate() and scheduleWithFixedDelay()
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.
52
What is a thread pool?
A thread pool is a group of pre-instantiated reusable threads that are available to perform a set of arbitrary tasks.
53
Which ExecutorService implementations use a thread pool?
- CachedThreadPool
- FixedThreadPool
- ScheduledThreadPool
54
What is the ExecutorService: CachedThreadPool?
An ExecutorService that creates a thread pool that creates new threads as needed but will reuse previously constructed threads when they are available.
55
What is the ExecutorService: FixedThreadPool?
An ExecutorService that creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.
56
What is the ScheduledExecutorService: ScheduledThreadPool?
A ScheduledExecutorService that creates a thread pool that can schedule commands to run after a given delay or to execute periodically.
57
Create a FixedThreadPool such that it behaves similarly to a SingleThreadExecutor.
ExecutorService service = Executors.newFixedThreadPool(1);
1 thread = same as SingleThreadExecutor.
58
What command is often used to determine the appropriate pool size?
Runtime.getRuntime().availableProcessors()
59
What is a race condition?
The unexpected result of two tasks executing at the same time.
60
What atomic classes are available, such that reading and updating the value is thread-safe?
- AtomicBoolean
- AtomicInteger
- AtomicLong
61
How can we make the following variable thread-safe such that it won't produce a race condition?
private int sheepCount = 0;
replace int by AtomicInteger
private AtomicInteger sheepCount = new AtomicInteger(0);
62
What is mutual exclusion?
the property that at most one thread is executing a particular segment of code at a given time.
63
What does the synchronized block do?
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.
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());
}
```
```
private void incrementAndReport() {
synchronized(this) {
System.out.println((++sheepCount)+ "");
}
}
```
or
private synchronized void incrementAndReport() {
System.out.println((++sheepCount)+ "");
}
65
What Java types can be used in a synchronized statement?
Any Object
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)+ "");
}
}
...
```
yes. We can synchronize on any object, as long as it is the same object.
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");
}
```
public static void printDaysOfWork() {
synchronized(Test.class) {
System.out.print("test");
}
}
```
or
public static synchronized void printDaysOfWork() {
System.out.print("test");
}
68
What is the equivalent of the following code, using the Lock interface?
```
Object object = new Object();
synchronized(object) {
// code
}
```
```
Lock lock = new ReentrantLock();
try {
lock.lock();
// code
} finally {
lock.unlock();
}
```
69
What is the Lock implementation class ReentantLock?
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().
70
What happens when you want to release a lock (lock.unlock()) that no thread has?
It will throw an IllegalMonitorStateException.
71
What methods does the Lock interface contain?
- 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.
72
What is the problem with the following code?
```
Lock lock = new ReentrantLock();
if(lock.tryLock()) {
try {
lock.lock();
} finally {
lock.unlock();
}
}
```
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.
73
The ReentrantLock class supports the same features as the synchronized block. What improvements are added?
- 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.
74
What is the CyclicBarrier class?
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.
75
given the following method, add the use of CyclicBarrier such that all threads wait after removing all lions.
performTasks() {
removeLions();
cleanPen();
}
```
performTasks(CyclicBarrier c) {
try {
removeLions();
c.await();
cleanPen();
} catch(InterruptedException | BrokenBarrierException) { }
}
```
76
What is the purpose of concurrent collection classes?
example: ConcurrentHashMap
to solve common memory consistency errors. A memory consistency error occurs when two threads have inconsistent views of what should be the same data.
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);
}
```
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.
78
When should you use concurrent collection classes?
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).
79
What type of objects can be accessed by multiple threads without ever having a concurrency problem?
immutable or read-only objects.
80
What is the difference between a Queue and a BlockingQueue?
The BlockingQueue is a regular Queue that includes methods that will wait a specific amount of time to complete an operation.
81
What is a LinkedBlockingQueue?
A LinkedBlockingQueue is an implementation of the BlockingQueue interface, which maintains a linked list between its elements.
82
How can you obtain a synchronized collection if you're not working with a concurrent collection class (such as ConcurrentHashMap)?
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)
- ...
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);
}
```
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.
84
What is liveness?
Liveness is the ability of an application to be able to execute in a timely manner.
85
What types of liveness issues exist?
- deadlock
- starvation
- livelock
86
What is deadlock?
Deadlock occurs when two or more threads are blocked forever, each waiting on the other.
87
What is starvation?
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.
88
What is livelock?
Livelock occurs when two or more threads are conceptually blocked forever, although they are each still active and trying to complete their task.
89
What are two ways to create a parallel stream?
- calling parallel() on an existing stream.
| - calling parallelStream() on a Collection Object.
