Concurrency: Foundation & Executor Framework

Question 1

What are the 2 ways of implementing a thread?

Answer 1

1. Extend the Thread class and overwrite the run() method

2. Implement the Runnable interface in a separate or anonymous class

Question 2

Which method should we use to execute the run() method of a thread?

Answer 2

the start() method

Question 3

What’s the purpose of the join() method?

Answer 3

With join() a thread can call another thread. Itself will be blocked until the other thread is terminated.

Question 4

In what states is the thread alive?

Answer 4

RUNNABLE (Ready, Running)

BLOCKED, WAITING, TIMED_WAITING (“Suspended”)

Question 5

What are the 6 different states of a thread?

Answer 5

NEW
RUNNABLE
BLOCKED
TIMED_WAITING
WAITING
TERMINATED

Question 6

What’s the advantage on implementing Runnable over extending the Thread class?

Answer 6

We can still extend a custom class (not only implement the Runnable). But when we extend the Thread class we can’t extend any further class because Java only supports single-inheritance.

Question 7

How can you stop or terminate a thread?

Answer 7

• wait until run() ends
• we can also implement a flag variable marked as volatile to end the run loop

-> terminate() or stop() should not be used (deprecated), because we leave the thread in an inconsistent state

Question 8

When is a thread alive?

Answer 8

From the moment when the thread has been started with start() the thread is alive. It stays alive as long as the run() method is still running.

Question 9

What’s the purpose of an Executor?

Answer 9

To start a Runnable task with the method execute()

Example:

class ThreadPerTaskExecutor implements Executor{ public void execute(Runnable task) {
new Thread(task).start();    
}
}

Question 10

What can an ExecutorService do, that a simple Executor can’t do?

Answer 10

It can control and also stop task execution.

Question 11

What happens when an ExecutorService calls shutdown()?

Answer 11

It stopps receiving tasks, waits until all accepted tasks have finished and then terminates the executor.

Question 12

What’s the difference between shutdown() and shutdownNow()?

Answer 12

shutdown() waits until all tasks have finished running, shutdownNow() interrupts the running tasks.

Question 13

Which class does ExecutorService extend?

Answer 13

Executors

e.g. ExecutorService executorService = Executors.newSingleThreadExecutor();

Question 14

Which statements are true?

a) when a thread in a thread pool dies, a new thread pool is created
b) thread pools are created once
c) thread pools use a set of worker threads that can be reused
d) when a task is submitted the task always goes directly into the thread pool and waits until it can be executed

Answer 14

b) and c)
- > thread pools are created only once
- > the set of worker threads can be reused

(tasks don’t go directly into the pool, they first go into the blocking queue, which holds the task until a thread becomes available)

Question 15

Name at least 3 different types of Thread Pools

Answer 15

• SingleThreadPool
• FixedThreadPool
• CachedThreadPool
• WorkStealingPool

Question 16

What’s the advantage of a ChachedThreadPool vs a FixedThreadPool?

Answer 16

a CachedThreadPool is more dynamic: creates new threads only as needed, can remove threads which aren’t used.
-> ideal for programs using many short-lived asynchronous tasks

Question 17

What are the 3 main methods of the ScheduledExecutorService?

Answer 17

schedule()
scheduleAtFixedRate()
scheduleWithFixedDelay()

Question 18

What are the 2 ScheduledExecutorServices provided by the Executors class?

Answer 18

• SingleThreadScheduled Executor -> thread pool size = 1

- ScheduledThreadPool -> uses given thread pool size

Question 19

What are the 2 types of nested classes in java?

Answer 19

• inner classes

- static nested classes

Question 20

Are inner classes static or non-static?

Answer 20

non-static

Question 21

When does it make sense to nest a class?

Answer 21

When it is only helpful / used in one class. -> more readable code, better encapsulation

Question 22

Can a static nested class directly access the members of the outer class?

Answer 22

No, it can only directly access the field if it is static.

Question 23

Can a private inner class be accessed by its outer class?

Answer 23

Yes.

Question 24

Can a top-level class be declared “private”?

Answer 24

No, only nested / inner classes can be declared private.

Question 25

What are the 2 main differences between Callable and Runnable?

Answer 25

• Callable can return a result

- Callable can throw a checked Exception if unable to compute a result

Question 26

What do the methods Future.isDone() and Future.get() do?

Answer 26

Future.isDone()
-> we ask if the result is available

Future.get()
-> we call get() to return the result

Question 27

What are the 2 options to return multiple Futures?

Answer 27

Option 1: Store the returned Futures of the submitted callables in a collection by using a for loop, then: for loop through collection with future.get()

Option 2: Use ExecutorService.invokeAll(taskList)
-> store the list that it returns and for loop through the stored list with future.get()

Question 28

What does ExecutorService.invokeAny() do?

Answer 28

Waits for the completion of the fastest callable, which doesn’t throw an Exception

Question 29

How do we separate the creation and management from the application logic?

Answer 29

By using the Java Executor Framework

Question 30

What are Futures used for?

Answer 30

To collect results from callables. They are like a placeholder for the result of the computation, which will be available at a later point in time.