Threads

Question 1

What is concurrency?

Answer 1

Execution of multiple threads or processes in same time

Question 2

What is context switching?

Answer 2

Process of returning to threads running state after its state change state at some point in time

Question 3

Can threads have priorities?

Answer 3

They can be prioritized over other threads

Question 4

How can we create new threads?

Answer 4

new Thread(Callable).start()
run() method doesn’t start a thread.

or

A class can implement Callable or Runnable interfaces, and then start() method can be executed.

Question 5

What is lifecycle of a thread?

Answer 5

1. NEW -> start()
2. RUNNABLE
   2a. BLOCKED - if resource is blocked. shared resource is lock.
   2b. WAITING - thread is waiting for other thread to wake it or complete - notify(), notifyAll()
   2c. TIMED_WAITING - same as WAITING, but it contains time limit
3. -> run() -> TERMINATED

Question 6

What is liveliness?

Answer 6

Applications responsivity.
Usually it is hurt when some thread or threads are constantly in WAIT or BLOCKED.

Question 7

What is deadlock?

Answer 7

It is a case when two or more threads are holding a shared resource which they all need.

Question 8

What is starvation?

Answer 8

Occurrence when some threads cannot get ahold of resources they need because other threads are constantly locking them away. Happens for eg. when prioritised threads always get resources before lower prioritised threads.

Question 9

What is livelock?

Answer 9

Situation where threads lock each other, but instead of going into WAITING or BLOCKED state, they keep on trying to get ahold of a locked resource.

Question 10

What collections are used in concurrency?

Answer 10

ConcurrentHashMap
ConcurrentLinkedQueue
ConcurrentSkipListMap
ConcurrentSkipListSet
CopyOnWriteArrayList
CopyOnWriteArraySet
LinkedBlockingQueue

All can be instantiated by Collections.

Question 11

ConcurrentHashMap

Answer 11

Thread-safe version of HashMap. Allows concurrent reads and a configurable number of concurrent writes.
Use cases: High-concurrency scenarios requiring frequent reads and occasional writes. Good for caching and shared mappings in multi-threaded applications.

Question 12

ConcurrentLinkedQueue

Answer 12

Characteristics: Non-blocking, thread-safe queue implementation based on linked nodes.
Use cases: When you need a high-performance, scalable queue for multiple producers and consumers.

Question 13

ConcurrentSkipListMap

Answer 13

Characteristics: Sorted, thread-safe map based on a skip list data structure. Provides expected O(log n) time for most operations.
Use cases: When you need a sorted, concurrent map with good performance for simultaneous reads and writes.

Question 14

ConcurrentSkipListSet

Answer 14

Characteristics: Sorted, thread-safe set based on ConcurrentSkipListMap.
Use cases: When you need a sorted, concurrent set with good performance for simultaneous reads and writes.

Question 15

CopyOnWriteArrayList

Answer 15

Characteristics: Thread-safe variant of ArrayList where all mutative operations create a fresh copy of the underlying array.
Use cases: When reads greatly outnumber writes, and iteration is very common. Often used for listener lists in event-driven programming.

Question 16

CopyOnWriteArraySet

Answer 16

Characteristics: Set implementation backed by CopyOnWriteArrayList.
Use cases: Similar to CopyOnWriteArrayList, but when you need set semantics (no duplicates).

Question 17

LinkedBlockingQueue

Answer 17

Characteristics: Optionally bounded blocking queue based on linked nodes.
Use cases: Producer-consumer scenarios, especially when you need to block producers when the queue is full or consumers when it’s empty.

Question 18

What is pooling in concurrency?

Answer 18

Checking of some data in some interval - is thread finished?

Question 19

What is race condition?

Answer 19

Situation where two or more processes or threads access shared data or resources simultaneously, and the final outcome depends on the timing or order of their execution. Eg. two users with same name are created at the same time.

Question 20

Decomposition using streams?

Answer 20

stream.parallel() or parallelStream()

Question 21

Reduction using streams?

Answer 21

reduce(identity, accumulator, combiner)
collect(supplier -> new collection, accumulator, combiner)

Question 22

Runnable?

Answer 22

Type of thread interface that implements start of a new thread, but it always returns null.

service.submit(() -> …) get()

Question 23

Callable?

Answer 23

Type of thread interface that implements start of a new thread, but it returns defined type by generic.

Future<T> result = service.submit(() ->... get()</T>

Question 24

What methods do Executors services have?

Answer 24

execute() - doesn’t return anything
submit() - returns Future
invokeAll() - executes all provided threads
invokeAny() - executes random provided thread

Question 25

What methods does Future have?

Answer 25

get() - waits for thread to complete and then return the result
get(timeout) - same as get(), but has timeout
isDone()
isCancelled()
cancel()

Question 26

What service is used to run single thread?

Answer 26

Executors.newSingleThreadExecutor()

Question 27

What is lifecycle of thread executor?

Answer 27

ACTIVE state - accepts new tasks and executes tasks
SHUTTING DOWN state - after shutdown() is ran, accepting new tasks is disabled, but execution of running tasks is happening
SHUTDOWN state - after isShutdown() is confirmed, no new tasks and task execution is allowed. State can be confirmed by isTerminated() or isShutdown()

Question 28

How can we run scheduled threads?

Answer 28

Using Executors.newSingleThreadScheduledExecutor()

Question 29

What methods does scheduled thread executor have?

Answer 29

schedule(Callable)
schedule(Runnable)
scheduledAtFixedRate - executes tasks without regarding previous tasks
sheduleWithFixedDelay - executes tasks when previous tasks complete

Question 30

What tools do we use to ensure thread safety?

Answer 30

synchronized keyword
Atomic classes
volatile keyword
Reetainent locks
Cyclic barriers

Question 31

synchronized keyword

Answer 31

Using monitors, or locks to ensure mutual exclusion (only one thread does its work).
Monitor or lock can be any object.
When thread comes to shared monitor, it locks sync. block to other threads. Any other thread that comes to that lock is blocked. When locking thread finishes, it releases the lock.

They can be used on code blocks or methods.

Question 32

What are downsides of “synchronized”?

Answer 32

Performance overhead
Risk of deadlock because it can easily lead to bad ordering of locking and unlocking

Question 33

Atomic classes?

Answer 33

Used to share value between threads. Threads wait until atomic operation is completed. They are consistent, but order of execution is not known.

Question 34

What are common atomic classes?

Answer 34

AtomicInteger
AtomicBoolean
AtomicLong

Question 35

What are common atomic classes methods?

Answer 35

get
set
getAndSet
incrementAndGet
getAndIncrement
decrementAndGet
getAndDecrement

Question 36

volatile keyword

Answer 36

Used on instance and static variables.
Cannot use compound actions on them (i++).
It ensures that only one thread is reading and writing to it.
Not thread safe because it doesn’t solve race conditions.
Data may not be consistent.

Question 37

RetainentLock

Answer 37

Lock lock = new RetainentLock()
try {
lock.lock()
// protected code
}

You can optionally add “finally” and put lock.unlock() in. There must be exact number of unlocks as the number of locks.

RetainentLock(true) can be set for “fairness”, which thread requests lock first will be using lock first. It should be used only if necessary, because it is not performant.

Question 38

What are common RetainentLock methods?

Answer 38

lock
unlock
tryLock -> locks and returns boolean
tryLock(TimeUnit) -> locks or waits specified time to get the key

Question 39

CyclicBarrier

Answer 39

Can be used to control parts of code by blocking threads from advancing before all threads get to specific part of code.

var c = new CyclicBarrier(4)

or

var c = new CyclicBarrier(4, Runnable). Runnable is optional and is run when barrier is hit.

try {
// …
c.await();
// …
} catch (BrokenBarrierException e) {
// …
}