93 lines
4.3 KiB
Markdown
93 lines
4.3 KiB
Markdown
|
||
## Question 1: `start()` vs `run()`
|
||
|
||
### What output do you get from the program?
|
||
|
||
|
||
|
||
The first call (`t1.run()`) prints `Running in: main` because it executes on the **main thread** directly — no new thread is created. The second call (`t2.start()`) properly spawns a new thread, so it prints `Running in: Thread-2`.
|
||
|
||
The `Thread.sleep(100)` between the two calls ensures `t2`'s output isn't interleaved with the first, but the ordering of the second line is still technically non-deterministic (it will almost always appear after `"Calling start()"`).
|
||
|
||
### What's the difference between `start()` and `run()`?
|
||
|
||
| | `run()` | `start()` |
|
||
|---|---|---|
|
||
| **Execution** | Runs on the **calling thread** (like a normal method call) | Spawns a **new OS thread** and runs `run()` on it |
|
||
| **Concurrency** | None — sequential, blocking | Concurrent — the calling thread continues immediately |
|
||
| **Thread name** | Uses the calling thread's name (`main`) | Uses the new thread's name (`Thread-2`) |
|
||
| **Thread lifecycle** | Does not transition the thread to `RUNNABLE` state | Properly starts the thread lifecycle |
|
||
|
||
Calling `run()` directly is just a regular method call. Only `start()` actually creates a new thread.
|
||
|
||
---
|
||
|
||
## Question 2: Daemon Threads
|
||
|
||
### What output do you get from the program?
|
||
|
||
```
|
||
Main thread ends.
|
||
Daemon thread running...
|
||
Daemon thread running...
|
||
(possibly a few more lines, then the program exits abruptly)
|
||
```
|
||
|
||
The exact number of "Daemon thread running..." lines is non-deterministic — typically 0 to 2. The JVM shuts down as soon as the **main thread** finishes, which kills all remaining daemon threads immediately, regardless of what they're doing.
|
||
|
||
### What happens if you remove `thread.setDaemon(true)`?
|
||
|
||
The thread becomes a regular (non-daemon) **user thread**. The JVM will **not exit** until all user threads complete. In this case, the loop runs all 20 iterations (taking ~10 seconds), printing `"Daemon thread running..."` 20 times before the program ends.
|
||
|
||
### Real-life use cases of daemon threads
|
||
|
||
- **Garbage Collector** – The JVM's own GC runs as a daemon thread; it should never prevent the JVM from shutting down.
|
||
- **Background logging** – Flushing logs or metrics to a file/server periodically, where losing the last few entries on shutdown is acceptable.
|
||
- **Heartbeat / keep-alive threads** – Sending periodic pings to a server while the application is alive.
|
||
- **Cache invalidation** – A background thread that evicts stale entries from an in-memory cache.
|
||
- **Auto-save** – Periodically saving a draft in an editor; the user closing the app shouldn't be blocked by this.
|
||
|
||
---
|
||
|
||
## Question 3: A Shorter Way to Create Threads (Lambda)
|
||
|
||
### What output do you get from the program?
|
||
|
||
```
|
||
Thread is running using a ...!
|
||
```
|
||
|
||
(Printed from the newly spawned thread.)
|
||
|
||
### What is the `() -> { ... }` syntax called?
|
||
|
||
It is called a **lambda expression** (introduced in Java 8). It provides a concise way to implement a **functional interface** — an interface with exactly one abstract method. Since `Runnable` has only one method (`run()`), a lambda can be used anywhere a `Runnable` is expected.
|
||
|
||
### How is this different from extending `Thread` or implementing `Runnable`?
|
||
|
||
| Approach | Code required | Reusability | Notes |
|
||
|---|---|---|---|
|
||
| `extends Thread` | Full class definition | Low — must subclass `Thread`, can't extend anything else | Tightly couples logic to thread machinery |
|
||
| `implements Runnable` | Full class + `new Thread(r)` | Higher — decouples task from thread | Preferred for named/reusable task classes |
|
||
| **Lambda** | One-liner inline | Low — anonymous, inline only | Best for short, one-off tasks |
|
||
|
||
The lambda approach is essentially **anonymous shorthand for `implements Runnable`** — the compiler generates an implementation of `Runnable.run()` under the hood. It is the most concise option but is best suited for simple, short tasks. For complex or reusable tasks, a named class implementing `Runnable` is clearer.
|
||
|
||
```java
|
||
// These three are functionally equivalent:
|
||
|
||
// 1. Class extending Thread
|
||
class MyThread extends Thread {
|
||
public void run() { System.out.println("Running"); }
|
||
}
|
||
new MyThread().start();
|
||
|
||
// 2. Anonymous Runnable
|
||
new Thread(new Runnable() {
|
||
public void run() { System.out.println("Running"); }
|
||
}).start();
|
||
|
||
// 3. Lambda (shortest)
|
||
new Thread(() -> System.out.println("Running")).start();
|
||
```
|