136 lines
4.5 KiB
Markdown
136 lines
4.5 KiB
Markdown
|
||
### 1. `start()` vs `run()`
|
||
|
||
```java
|
||
public class StartVsRun {
|
||
static class MyRunnable implements Runnable {
|
||
public void run() {
|
||
System.out.println("Running in: " + Thread.currentThread().getName());
|
||
}
|
||
}
|
||
public static void main(String[] args) throws InterruptedException {
|
||
Thread t1 = new Thread(new MyRunnable(), "Thread-1");
|
||
System.out.println("Calling run()");
|
||
t1.run();
|
||
Thread.sleep(100);
|
||
|
||
Thread t2 = new Thread(new MyRunnable(), "Thread-2");
|
||
System.out.println("Calling start()");
|
||
t2.start();
|
||
}
|
||
}
|
||
```
|
||
|
||
**Questions:**
|
||
|
||
- ##### What output do you get from the program? Why?
|
||
|
||
|
||
- ##### What’s the difference in behavior between calling `start()` and `run()`?</br>
|
||
|
||
|
||
**answers :**
|
||
|
||
```
|
||
Calling run()
|
||
Running in: main
|
||
Calling start()
|
||
Running in: Thread-2
|
||
```
|
||
Because when we call " **t1.run()** ", it does not create a new thread. we have just called run method in class main so it prints "**Running in: main**".
|
||
</br>
|
||
But when we call " **t2.start()** " it creates a new thread and it calls the run method of this object on the new thread so it prints "**Running in: Thread-2**"
|
||
|
||
---
|
||
### 2. Daemon Threads
|
||
```java
|
||
public class DaemonExample {
|
||
static class DaemonRunnable implements Runnable {
|
||
public void run() {
|
||
for(int i = 0; i < 20; i++) {
|
||
System.out.println("Daemon thread running...");
|
||
try {
|
||
Thread.sleep(500);
|
||
} catch (InterruptedException e) {
|
||
//[Handling Exception...]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
public static void main(String[] args) {
|
||
Thread thread = new Thread(new DaemonRunnable());
|
||
thread.setDaemon(true);
|
||
thread.start();
|
||
System.out.println("Main thread ends.");
|
||
}
|
||
}
|
||
```
|
||
|
||
**Questions:**
|
||
- ##### What output do you get from the program? Why?
|
||
|
||
**answer :**
|
||
|
||
output :
|
||
```
|
||
Main thread ends.
|
||
Daemon thread running...
|
||
```
|
||
because the Main Thread finishes quickly but the Daemon tries to print messages for 20 times so the JVM kills the Daemon Thread abruptly, even if it hasn’t finished its work.
|
||
|
||
|
||
- ##### What happens if you remove `thread.setDaemon(true)`?
|
||
|
||
|
||
**answer :**</br>
|
||
Even though the main thread finishes, the JVM keeps the program running until the new User Thread completes its 20 iterations. The full output will be printed.
|
||
- ##### What are some real-life use cases of daemon threads?</br>
|
||
|
||
|
||
**answer :**</br>
|
||
- _**Garbage Collection:**_</br>
|
||
The JVM itself uses daemon threads for memory cleanup. They run in the background to free up occupied memory so the main application can continue running smoothly.
|
||
- **_Logging:_**</br>
|
||
Threads that write log messages to files are often daemons. This ensures that if the main application shuts down abruptly, the logging process doesn’t block it or cause delays.
|
||
- **_Health Checks:_**</br>
|
||
Services that periodically check if the system is healthy (such as verifying database connectivity) usually run as daemon threads.
|
||
- **_Pre-loading:_**</br>
|
||
When an application is starting up, daemon threads can prepare necessary data in advance. This helps improve the speed and responsiveness of the application once it’s fully loaded.
|
||
|
||
---
|
||
|
||
### 3. A shorter way to create threads
|
||
|
||
```java
|
||
public class ThreadDemo {
|
||
public static void main(String[] args) {
|
||
Thread thread = new Thread(() -> {
|
||
System.out.println("Thread is running using a ...!");
|
||
});
|
||
|
||
thread.start();
|
||
}
|
||
}
|
||
```
|
||
|
||
**Questions:**
|
||
|
||
- ##### What output do you get from the program?
|
||
|
||
**answer:**</br>
|
||
output:
|
||
```
|
||
Thread is running using a ...!
|
||
```
|
||
|
||
- ##### What is the `() -> { ... }` </br>
|
||
|
||
**answer:**</br>
|
||
This syntax is called a Lambda Expression. It provides a concise way to represent instances of functional interfaces (interfaces with only one abstract method).
|
||
- #### How is this code different from creating a class that extends `Thread` or implements `Runnable`?
|
||
|
||
**answer:**</br>
|
||
**Less Code:** With Lambda, you don’t need to create a separate class (either extending Thread or implementing Runnable) and override the run() method. You write the logic directly inside the Thread constructor.
|
||
|
||
**Flexibility:** While extending Thread forces you to create a new class hierarchy, and implementing Runnable requires an extra class or anonymous inner class, Lambda allows you to pass the behavior directly as an argument.
|