116 lines
3.8 KiB
Markdown
116 lines
3.8 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();
|
||
}
|
||
}
|
||
```
|
||
|
||
#### What output do you get from the program? Why?
|
||
- The output is:
|
||
```
|
||
Calling run()
|
||
Running in: main
|
||
Calling start()
|
||
Running in: Thread-2
|
||
```
|
||
Since `t1.run()` executes the `run()` method directly inside the main thread, but `t2.start()` executes it inside the created new thread.
|
||
|
||
#### What’s the difference in behavior between calling `start()` and `run()`?
|
||
- Calling `run()` is just a normal method call, so the program waits for it to finish before moving to the next line.
|
||
|
||
Calling `start()` tells Java to create a new thread and execute the `run()` method inside it, which allows it to run alongside the main thread.
|
||
|
||
---
|
||
### 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.");
|
||
}
|
||
}
|
||
```
|
||
|
||
#### What output do you get from the program? Why?
|
||
- The output is:
|
||
```
|
||
Main thread ends.
|
||
Daemon thread running...
|
||
```
|
||
Since `thread.setDaemon(true)` marks the thread as a background "daemon" thread, the program ends as soon as all user (non-daemon) threads (the main thread in this case) have finished, regardless of whether the daemon thread has completed its task.
|
||
|
||
#### What happens if you remove `thread.setDaemon(true)`?
|
||
- The program continues printing `Daemon thread running...` 20 times even after the main thread has finished.
|
||
```
|
||
Main thread ends.
|
||
Daemon thread running...
|
||
.
|
||
.
|
||
.
|
||
Daemon thread running...
|
||
```
|
||
|
||
#### What are some real-life use cases of daemon threads?
|
||
- In general, when we want a background task to run **only** while the main program is running, we use daemon threads.
|
||
|
||
For example, background tasks like cache clearing, checking connectivity to a server, or monitoring CPU/Memory usage can all be done using daemon threads.
|
||
|
||
---
|
||
### 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();
|
||
}
|
||
}
|
||
```
|
||
|
||
#### What output do you get from the program?
|
||
- The output is:
|
||
```
|
||
Thread is running using a ...!
|
||
```
|
||
|
||
#### What is the () -> { ... } syntax called?
|
||
- It's called a lambda expression
|
||
|
||
#### How is this code different from creating a class that extends Thread or implements Runnable?
|
||
- It’s much shorter and easier to read. Instead of having to define a new custom thread class (by extending Thread)
|
||
or separate the task from the thread itself (by implementing Runnable) just to run a few lines of code,
|
||
a lambda expression lets us pass the code directly to the thread.
|