MultithreadingPart2

Question 1

Thread vs Runnable

Answer 1

you can implement Runnable and extend from another class as well

Question 2

start() vs run()

Answer 2

start a Thread
vs
just execute run() method

Question 3

wait()/notify() usage

Answer 3

Object.wait() – to suspend a thread
Object.notify() – to wake a thread up

Question 4

sleep() vs wait()

Answer 4

wait() – until call notify(), notifyAll() from object
sleep() – until at least time expire or call interrupt().

Question 5

atomic operations
(internal implementation of atomic)

Answer 5

through CPU instructions, volatile and CAS

Question 6

CAS operation

Answer 6

CAS operation (compare-and-swap):
memory location M
existing expected value: A
new value B

The CAS operation updates atomically the value in M to B,
but only if the existing value in M matches A, otherwise no action is taken.

If so - handle failure manually

Question 7

volatile
should we rely on volatile?

Answer 7

it cannot be cached into the computer’s(microprocessor) cache memory by any thread
If there is a write operation going on a volatile variable, and suddenly a read operation is requested, it is guaranteed that the write operation will be finished prior to the read operation.

race condition is possible if previous value is needed to define next value
several threads could read same value

Question 8

Thread local? What are they needed for?

Answer 8

variables that can only be read and written by the same thread

Question 9

Does child thread see the value
of parent thread local?

Answer 9

If you mean InheritableThreadLocal
(extending ThreadLocal), then yes, each
child thread will have the initial default value
to be the same as the parent thread value.
But any changes by the child thread will be local to the child.

Question 10

Deadlock definition
example

Answer 10

deadlock is a state in which each member of
a group of actions, is waiting for some other
member to release a lock

Question 11

Livelock definition
example

Answer 11

special case of resource starvation where two
processes follow an algorithm for resolving a deadlock
that results in a cycle of different locked states because
each process is attempting the same strategy to avoid the lock.

Question 12

Starvation definition
example

Answer 12

situation where a thread is unable to gain regular
access to shared resources and is unable to make progress.
This happens when shared resources are made unavailable
for long periods by “greedy” threads.

Question 13

Race condition definition
exampple

Answer 13

when two or more threads can access
shared data and they try to change it at the same time

Question 14

Executors
Types

Answer 14

ExecutorService can execute Runnable and Callable tasks

cachedThreadPool creates new threads as needed, but will reuse previously constructed threads when they are available
SingleThreadPool single worker thread operating off an unbounded queue, and uses the provided ThreadFactory to create a new thread when needed.
FixedThreadPool reuses a fixed number of threads

If you want to process all submitted tasks in order of arrival, just use newFixedThreadPool(1)
If you want to optimize performance of big computation of recursive tasks, use ForkJoinPool or newWorkStealingPool
If you want to execute some tasks periodically or at certain time in future, use newScheduledThreadPool

Question 15

Happens-before

Answer 15

When thread A enter sync for operation block and thread B is waiting. Then JVM guarantee A happens before B when thread B will know correct all values inialized by first thread before A operation. Other values JVM can reorder by hardware specific.
When A and B in the diffenent processes then JVM guarantee communication from A to B.
Transitivity of ““happens before””: A -> B and B -> C then A -> C

Question 16

volatile vs atomic

Answer 16

Vollatile - one atomic operation. Atomics - few operations can be atomic.
volatile read vs getAndAdd(7)

Question 17

Garbage definition plus example

Answer 17

unused objects or objects that are out of reach

Question 18

Atomicity of long and double assignment
operations

Answer 18

single write to a non-volatile long or double
value is treated as two separate writes:
one to each 32-bit half

volatile grants atomicity

Question 19

What is Fork-Join?

Answer 19

provides tools to help speed up parallel processing
recursively breaking the task into smaller independent subtasks
results of all subtasks are recursively joined into a single result

Question 20

ForkJoinPool

Answer 20

Worker threads can execute only one task at the time,
but the ForkJoinPool doesn’t create a separate thread
for every single subtask. Instead, each thread in the pool
has its own double-ended queue (or deque, pronounced deck) which stores tasks.

Question 21

Reentrant lock

Answer 21

As the name says, ReentrantLock allow
threads to enter into lock on a resource
more than once. When the thread first enters
into lock, a hold count is set to one.
Before unlocking the thread can re-enter into
lock again and every time hold count is
incremented by one. For every unlock request,
hold count is decremented by one and when
hold count is 0, the resource is unlocked.

Question 22

work-stealing algorithm

Answer 22

free threads try to “steal” work from deques of busy threads.