Added REPORT.md for the theoretical questions

Finished ProgressMonitor, DownloadWorker and Main classes.
2026-06-02 14:17:00 +03:30
parent 9e5c715088
commit 5eb6343ba6
4 changed files with 140 additions and 64 deletions
@@ -0,0 +1,86 @@
+## Q1
+```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();    
+    }  
+}  
+```
+### Answer 
+#### Output
+the program first outputs `Calling run()`  
+then it runs the `t1` by calling the `run` method in the `t1` thread  
+t1's run method outputs `Running in: Thread-1`
+
+the program waits 100ms (`Thread.sleep(100)`) after that a new thread is created called `t2`  
+the program outputs `Calling start()` and then `Running in: Thread-2` 
+
+#### Difference between `run()` and `start()`
+when we call `t1.run()` the program stops at this line, no new thread would be created and run method runs on the main thread  
+but when we call `t2.start()` a new thread would get created and main thread runs alongside the new thread.
+
+## Q2
+```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.");    
+    }  
+}
+```
+### Answer 
+#### Output
+The program creates a thread from DaemonRunnable class, after that it sets to a be a daemon  output first message: `Daemon thread running...` and just as it's in sleep (`Thread.sleep(500)`) the main thread finishes its job  
+and outputs: `Main thread ends.`. this would end the daemon thread we started.
+#### What if we removed `thread.setDaemon(true)`
+if we removed this line `thread` would've been a normal thread, meaning when we reach the end of the main thread `thread` would still continue doing its work (which is printing `Daemon thread running...`)  
+The Main thread would've waited for `thread` to finish its job before ending the program.
+#### Real life use cases
+`sshd` is a daemon that listens for any SSH connections to the computer  
+another example would be `systemd` which is a daemon on most of the linux distros that manages services 
+
+## Q3
+```java
+public class ThreadDemo {  
+    public static void main(String[] args) {  
+        Thread thread = new Thread(() -> {  
+            System.out.println("Thread is running using a ...!");  
+        });  
+  
+        thread.start();  
+    }  
+}   
+```
+### Answer
+#### Output
+the program simply just outputs `Thread is running using a ...!`
+#### What is the `() -> {...}` syntax called
+`() -> {...}` is a lambda expression with no parameters: `()`
+#### Difference between this and a normal class
+using this lambda expression we don't need to create another class