diff --git a/Report.md b/Report.md
new file mode 100644
index 0000000..6a25b07
--- /dev/null
+++ b/Report.md
@@ -0,0 +1,92 @@
+
+## 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();
+```
diff --git a/src/main/java/DownloadWorker.java b/src/main/java/DownloadWorker.java
index 546de2d..4e1cc60 100644
--- a/src/main/java/DownloadWorker.java
+++ b/src/main/java/DownloadWorker.java
@@ -1,12 +1,5 @@
import java.util.Random;
-/**
- * Simulates downloading a single chunk of a file.
- *
- * This class is intentionally provided as a skeleton for students.
- * The main multithreading and simulation logic should be completed
- * in the run() method.
- */
public class DownloadWorker implements Runnable {
private final ChunkStatus chunkStatus;
@@ -21,23 +14,32 @@ public class DownloadWorker implements Runnable {
@Override
public void run() {
- // TODO: Record the chunk start time in chunkStatus.
+
double downloaded = 0.0;
-
- // TODO: Print a message that this chunk has started downloading.
-
+ long startTime = System.currentTimeMillis();
+ chunkStatus.setStartTimeMs(startTime);
+ System.out.println("Chunk: " + chunkStatus.getChunkId() + " has started downloading.");
while (downloaded < chunkStatus.getChunkSizeMB()) {
- // TODO: Generate a random sleep delay between min and max delay.
- // TODO: Sleep for that delay.
- // TODO: Generate a random download amount for this step.
- // TODO: Increase downloaded, but do not go beyond chunk size.
- // TODO: Save the updated downloaded value into chunkStatus.
- // TODO: Optionally print step-by-step progress.
+
+ long randomSleep = random.nextLong(config.getMinStepDelayMs(), config.getMaxStepDelayMs());
+
+ try {
+ Thread.sleep(randomSleep);
+ }
+ catch (InterruptedException e) {
+ System.out.println(e.getMessage());
+ }
+
+ double down = random.nextDouble();
+ downloaded = Math.min(downloaded + down, chunkStatus.getChunkSizeMB());
+ chunkStatus.setDownloadedMB(chunkStatus.getDownloadedMB() + down);
}
- // TODO: Mark the chunk as completed.
- // TODO: Record the chunk end time in chunkStatus.
- // TODO: Print a message that this chunk has finished downloading.
+ chunkStatus.setCompleted(true);
+ Long endTime = System.currentTimeMillis();
+ chunkStatus.setEndTimeMs(endTime);
+ System.out.println("Chunk: " + chunkStatus.getChunkId() +
+ " has completed downloading (" + chunkStatus.getDownloadDurationMs() +" ms)");
}
}
diff --git a/src/main/java/Main.java b/src/main/java/Main.java
index 82bd239..b69bede 100644
--- a/src/main/java/Main.java
+++ b/src/main/java/Main.java
@@ -1,5 +1,6 @@
import java.util.ArrayList;
import java.util.List;
+import java.util.Random;
public class Main {
public static void main(String[] args) {
@@ -19,13 +20,13 @@ public class Main {
System.out.println("Chunk count: " + config.getChunkCount());
System.out.println();
- // 2. Create chunks
+
List chunks = ChunkUtils.createChunks(
config.getTotalSizeMB(),
config.getChunkCount()
);
- // 3. Create worker threads
+
List workerThreads = new ArrayList<>();
for (ChunkStatus chunk : chunks) {
@@ -34,50 +35,37 @@ public class Main {
workerThreads.add(workerThread);
- // TODO:
- // Students may print helpful debug information here,
- // for example which chunk is assigned to which worker thread.
+ System.out.println("Assigned Worker-" + chunk.getChunkId()
+ + " to chunk #" + chunk.getChunkId()
+ + " (" + chunk.getChunkSizeMB() + " MB)");
}
- // 4. Create and start monitor thread
+ System.out.println();
+
ProgressMonitor monitor = new ProgressMonitor(config, chunks);
Thread monitorThread = new Thread(monitor, "Progress-Monitor");
+
+ monitorThread.start();
- // TODO:
- // Start the monitor thread before starting the workers
- // so that progress can be displayed while downloading happens.
- //
- // Example idea:
- // monitorThread.start();
+ for (Thread workerThread : workerThreads) {
+ workerThread.start();
+ }
- // 5. Start worker threads
- // TODO:
- // Start each worker thread in workerThreads.
- // Use a loop and call start() on each thread.
+ for (Thread workerThread : workerThreads) {
+ try {
+ workerThread.join();
+ } catch (InterruptedException e) {
+ System.out.println("Thread was interrupted: " + e.getMessage());
+ }
+ }
- // 6. Wait for workers to finish
- // TODO:
- // Wait for all worker threads to complete by calling join().
- // This should be done inside a try-catch block for InterruptedException.
- //
- // Hint:
- // for (Thread thread : workerThreads) {
- // thread.join();
- // }
+ try {
+ monitorThread.join();
+ }
+ catch (InterruptedException e) {
+ System.out.println("Thread was interrupted: " + e.getMessage());
+ }
- // TODO:
- // After all workers finish, the monitor thread may also need to stop.
- // Depending on how ProgressMonitor is implemented, students may:
- // - wait for it to finish on its own, or
- // - add a stopping mechanism in ProgressMonitor later.
- //
- // If your monitor finishes automatically, you may join it here.
-
- // NOTE:
- // this final report may show 0 progress because no worker has actually run yet.
- // Until students complete the thread start/join TODOs above,
-
- // 7. Print final report
System.out.println();
System.out.println("=== Final Report ===");
@@ -91,17 +79,15 @@ public class Main {
completedChunks++;
}
- System.out.println(
- "Chunk " + chunk.getChunkId()
- + ": " + chunk.getDownloadedMB()
- + "/" + chunk.getChunkSizeMB()
- + " MB"
- );
+ System.out.printf(" Chunk %d: %.2f/%.0f MB | Duration: %d ms%n",
+ chunk.getChunkId(), chunk.getDownloadedMB(),
+ chunk.getChunkSizeMB(), chunk.getDownloadDurationMs());
+
}
System.out.println();
- System.out.println("Completed chunks: " + completedChunks + "/" + chunks.size());
- System.out.println("Downloaded total: " + downloadedMB + "/" + config.getTotalSizeMB() + " MB");
- System.out.println("Simulation finished.");
+ System.out.println("Completed chunks : " + completedChunks + "/" + chunks.size());
+ System.out.printf("Downloaded total : %.2f/%d MB%n", downloadedMB, config.getTotalSizeMB());
+
}
}
diff --git a/src/main/java/ProgressMonitor.java b/src/main/java/ProgressMonitor.java
index 475c0e0..7280439 100644
--- a/src/main/java/ProgressMonitor.java
+++ b/src/main/java/ProgressMonitor.java
@@ -16,16 +16,7 @@ public class ProgressMonitor implements Runnable {
@Override
public void run() {
- // TODO:
- // Repeatedly check chunk progress until all chunks are completed.
- // In each loop:
- // 1. Read the downloaded size from every chunk
- // 2. Add all downloaded amounts to totalDownloadedMB
- // 3. Count completed chunks
- // 4. Print a progress message
- // 5. If completedChunks == chunks.size(), print a final monitor message and stop
- // 6. Otherwise sleep for monitorDelayMs and continue
-
+ double previousProgress = 0.0;
while (true) {
double totalDownloadedMB = 0.0;
@@ -44,25 +35,49 @@ public class ProgressMonitor implements Runnable {
percent = (totalDownloadedMB * 100.0) / totalSizeMB;
}
- System.out.printf(
- "Progress for %s: %.1f/%.1f MB (%.2f%%), completed chunks: %d/%d%n",
- fileName,
- totalDownloadedMB,
- (double) totalSizeMB,
- percent,
- completedChunks,
- chunks.size()
- );
+
+ double deltaMB = totalDownloadedMB - previousProgress;
+ double speedMBps = deltaMB / (monitorDelayMs / 1000.0);
+ previousProgress = totalDownloadedMB;
- // TODO:
- // If all chunks are completed, print a final message and exit the loop
+ double remainingMB = totalSizeMB - totalDownloadedMB;
+ long etaSeconds = (speedMBps > 0) ? (long)(remainingMB / speedMBps) : 0;
- try {
- Thread.sleep(monitorDelayMs);
- } catch (InterruptedException e) {
- System.out.println("Progress monitor interrupted.");
- return;
+
+ int barWidth = 30;
+ int filled = (int)(percent / 100.0 * barWidth);
+ filled = Math.min(filled, barWidth);
+ String bar = "=".repeat(filled) + (filled < barWidth ? ">" : "") + " ".repeat(Math.max(0, barWidth - filled - 1));
+
+
+ System.out.printf("\r[%-30s] %5.1f%% | %5.1f/%d MB | Speed: %.2f MB/s | ETA: %ds | Chunks: %d/%d ",
+ bar, percent, totalDownloadedMB, totalSizeMB,
+ speedMBps, etaSeconds,
+ completedChunks, chunks.size());
+
+// System.out.printf(
+// "Progress for %s: %.1f/%.1f MB (%.2f%%), completed chunks: %d/%d%n",
+// fileName,
+// totalDownloadedMB,
+// (double) totalSizeMB,
+// percent,
+// completedChunks,
+// chunks.size()
+// );
+
+
+ if (completedChunks == chunks.size()) {
+ System.out.println("download completed!");
+ break;
+ } else {
+
+ try {
+ Thread.sleep(monitorDelayMs);
+ } catch (InterruptedException e) {
+ System.out.println("Progress monitor interrupted.");
+ return;
+ }
}
}
}
diff --git a/src/main/resources/download_config.txt b/src/main/resources/download_config.txt
index 6ddd6ca..bfb6dac 100644
--- a/src/main/resources/download_config.txt
+++ b/src/main/resources/download_config.txt
@@ -1,7 +1,7 @@
fileName=movie.mkv
totalSizeMB=120
-chunkCount=6
-minStepDelayMs=80
-maxStepDelayMs=200
-minStepDownloadMB=2
-maxStepDownloadMB=6
\ No newline at end of file
+chunkCount=10
+minStepDelayMs=200
+maxStepDelayMs=600
+minStepDownloadMB=.1
+maxStepDownloadMB=.4
\ No newline at end of file