Java Thread States Questions

When does a thread enter the runnable state?

Answer:
When the start() method is invoked.

What state must a thread be in, in order for the scheduler to select it from the runnable pool?

Answer:
The thread must be in the Running state.

Which three states can a thread be in when it is not eligible to run?

Answer:
In the context of Java programming, threads can exist in several states throughout their lifecycle, as defined by the Java Language Specification and the `java.lang.Thread` class. When a thread is not eligible to run, it can be in one of the following three states:
1. Blocked State: A thread enters the blocked state when it tries to access a synchronized block or method but cannot obtain the lock because another thread is already holding the lock. In this state, the thread is inactive and waiting for the lock to be released by the other thread. The blocked state is crucial for handling concurrency, as it prevents multiple threads from accessing a critical section of code simultaneously, thus avoiding data inconsistencies and race conditions.
2. Waiting State: A thread enters the waiting state when it is waiting for another thread to perform a particular action. This typically occurs in scenarios involving inter-thread communication, where a thread must wait for another thread to complete a task or signal a condition before it can proceed. Methods such as `Object.wait()`, `Thread.join()`, and `LockSupport.park()` are commonly used to put a thread into the waiting state. A thread in this state remains inactive until it receives a notification, typically through methods like `Object.notify()`, `Object.notifyAll()`, or `LockSupport.unpark(Thread)`.
3. Timed Waiting State: Similar to the waiting state, the timed waiting state occurs when a thread is waiting for another thread to perform an action, but with a specified maximum waiting time. This state is employed in scenarios where a thread needs to wait for a certain condition to be met within a specific time limit, after which it will proceed regardless of whether the condition has been met. Methods that can cause a thread to enter the timed waiting state include `Thread.sleep(long millis)`, `Object.wait(long timeout)`, and `Thread.join(long millis)`. The timed waiting state allows for more granular control of thread execution by incorporating timeouts, thereby preventing threads from waiting indefinitely.
These states are part of the thread lifecycle management in Java, enabling sophisticated control over thread execution and synchronization, which are foundational to building concurrent and multi-threaded applications. Understanding these states and how to manage transitions between them is essential for effective thread management and the development of responsive and efficient Java applications.
1. blocked
2. sleeping
3. Waiting

What are 2 static methods of the Thread class?

Answer:
```
1) t.sleep();
2) t.yield();
```

When is a thread considered to be dead?

Answer:
A thread is considered dead when its run() method completes.

What are 2 reasons you would want a thread to sleep?

Answer:
1. You think the thread is moving too quickly through the code
2. You might need to force your threads to take turns

Why does the sleep method have to be in a try catch block?

Answer:
The sleep() method can throw a checked InterruptedException, so you must acknowledge the exception using a 1) try-catch block or 2) by having the method throw an exception.

What happens when a thread wakes up?

Answer:
It goes back to the runnable state.

What are 3 assumptions that you have to make with respect to the sleep method?

Answer:
1. The time specified in sleep() is the minimum duration in which the thread will not run
2. You cannot rely on the sleep() method as a perfect accurate timer
3. sleep() time is not a guarantee that the thread will start running again as soon as the time expires and the thread wakes

How should you use thread priorities?

Answer:
As a way to improve the efficiency of your program.

Is the "Timed Waiting State" the same as the "Sleep State" in the Java Threading Model?

Answer:
No, the "Timed Waiting State" and the "Sleep State" in the Java Threading Model are different, although they both involve waiting:
Timed Waiting State:
- What it is: A state where a thread waits for a specific event to occur or for a specified amount of time to elapse, whichever comes first.
- How it happens: This state can be caused by methods like:
  1. `Object.wait(timeout)`
  2. `Thread.join(timeout)`
  3. `LockSupport.parkNanos(timeout)`
- Meaning: The thread is actively waiting for something and will become runnable again either when the timeout expires or the event happens.
- Examples: Waiting for another thread to finish a task, waiting for network data to arrive, or waiting for a specific time to trigger an action.
Sleep State:
- What it is: A state where a thread simply pauses its execution for a specified amount of time.
- How it happens: This state is caused by the `Thread.sleep(time)` method.
- Meaning: The thread is completely idle and can't be interrupted or notified. It essentially becomes unavailable for execution for the specified time.
- Event vs. Time: Timed waiting state allows for an event to occur before the timeout, while sleep state only has a time-based trigger.
- Interruptibility: A thread in timed waiting can be interrupted, while a thread in sleep state cannot.
- Resource usage: Timed waiting threads still consume some resources for monitoring, while sleeping threads release all resources.
In summary, timed waiting state offers more flexibility and responsiveness because it waits for either an event or a timeout, while the sleep state is simpler and offers complete idleness for a specific duration.