Java Interview Guide: How to Build Confidence With a Solid Understanding of Core Java Principles pdfdrive com

Thread Lifecycle
A thread is born by instantiating a subclass of the Thread class, or by
instantiating a Thread object with a Runnable argument. A thread enters
a runnable state when its start() method is invoked. The JVM uses
a priority-based scheduling algorithm to determine which thread to execute.
A thread enters a running state when its run() method is invoked by the
scheduler. However, a thread can transition into a blocked state if it needs
to acquire a lock or if it waits for a notification from another thread. A thread
dies after the run() method completes.

---

Synchronization
Synchronization is required on mutable resources because the operations
of multiple threads can interleave. For example, the c++ operation may appear
to be atomic, but it is actually composed of three steps: read the value of c,
increment the value of c, and write the value of c. If one thread reads the value
of c and enters a blocked state, a second thread could read the same value and
the counter would only be incremented by one. Synchronizing access to the c++
operation would force all three steps to be completed atomically.
Although synchronization can prevent thread interference and memory
consistency errors, it can also degrade performance and open up the possibility
of a deadlock. A deadlock occurs when two threads wait for each to proceed.

---

The Synchronize Keyword
The synchronize keyword is used to designate synchronized methods and
statements. A synchronized block of code is guarded by a lock that can only
be acquired by one thread at a time. In a synchronized static method,
the singleton Class object is implicitly used as the lock. In a synchronized non-
static method, the object instance is implicitly used as the lock. In a
synchronized statement, the lock must be provided as an argument. Multiple
locks allow for more granular levels of synchronization.
For example, imagine a Counter class with a synchronized count() method.
If the count() method was static, only one thread in the application could
increment the counter at a time. If the count() method was non-static,
multiple Counter objects could be instantiated and incremented concurrently.
If the Counter class had two separate variables and two separate count()
methods, each method could use synchronized statements with different locks
so that both variables could be incremented concurrently.

---