Eighth Assignment: Multithreading Basics

Table of contents

• Introduction
• Objectives 🎯
• Theoretical Questions 📝
• Practical Questions 💻
• Evaluation ⚖️
• Submission ⌛
• Additional Resources 📚

Important Note:

This project is configured as a Maven project. If you're opening this project in an IDE (like IntelliJ IDEA or VS Code), please ensure you import it as a Maven project so that dependencies and build settings are recognized automatically.

To run the project from the command line, use:

mvn compile
mvn exec:java -Dexec.mainClass="Main"

Introduction

Welcome to your Eighth Advanced Programming (AP) Assignment. This project is divided into two main sections:

1. Theoretical Questions: Analyze key multithreading concepts (Start vs Run, Daemon threads, and Lambdas).
2. Practical Questions: Implement a Simulated Download Manager. You will use Java Threads to simulate downloading a file in multiple chunks concurrently.

⚠️ Note: This is a local simulation only. There is no actual network activity, URL connection, or socket programming involved. The goal is to practice thread management and state observation.

Objectives 🎯

By completing this assignment, you will:

• Apply multithreading basics using the Thread class and Runnable interface.
• Understand how to manage multiple worker threads performing independent tasks.
• Implement a monitor thread to observe the progress of other threads.
• Practice using start() and join() for thread lifecycle management.

Theoretical Questions 📝

Note: Please answer these questions in a Markdown file (Report.md) and place it in the root directory of your fork. Include code or screenshots where you see fit.

1. start() vs run()

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()?

---

2. Daemon Threads

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?

• What happens if you remove thread.setDaemon(true)?

• What are some real-life use cases of daemon threads?

---

3. A shorter way to create threads

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?

• What is the () -> { ... } syntax called?

• How is this code different from creating a class that extends Thread or implements Runnable?

Practical Questions 💻

Simulated Download Manager

You are tasked with completing a skeleton project for a download manager. The application reads a configuration file, splits a "file" into several chunks, and assigns each chunk to a dedicated worker thread.

🏗 Project Structure

• src/main/resources/download_config.txt: Contains simulation parameters (file size, chunk count, delays).
• DownloadWorker.java: The logic for simulating a chunk download (needs implementation).
• ProgressMonitor.java: A thread that periodically prints the total progress (needs implementation).
• Main.java: The entry point that initializes chunks, starts threads, and waits for completion.
• ChunkStatus.java: Data class holding the state of individual chunks.

🛠 What You Need to Do

In the provided source code, look for // TODO comments. You must:

1. Implement DownloadWorker:
   • Record start/end times for each chunk.
   • Use a loop to simulate progress based on the random delays and step sizes provided in the config.
   • Update the shared ChunkStatus object so the monitor can see progress.
2. Implement ProgressMonitor:
   • Periodically calculate the total downloaded megabytes across all chunks.
   • Exit gracefully once all chunks are marked as completed.
3. Complete Main:
   • Properly instantiate and start() the worker threads and the monitor thread.
   • Use join() to ensure the main thread waits for all workers to finish before printing the final report.

⚙️ Configuration

The simulation behavior is controlled by src/main/resources/download_config.txt. You can modify these values to test different scenarios (e.g., more chunks or faster/slower speeds).

---

Bonus Tasks 🌟

• Download Speed and ETA:

  • Calculate and display the current overall download speed during the simulation.
  • Estimate and show the remaining time (ETA) based on the current progress and speed.

• User Interface (UI):

  • Improve the console output or design a simple UI that presents download progress in a cleaner and more intuitive way.
  • Make the simulation easier to follow by showing chunk activity, total progress, and final results in a user-friendly format.

• Real-Time Progress Bar:

  • Implement a real-time progress bar that updates in place instead of printing a new line each time.
  • Show smooth progress growth in the console so the output looks more like a real download manager.

• Sequential vs Multithreaded Comparison:

  • Add a mode to simulate downloading chunks sequentially (one after another) and compare it with the multithreaded version.
  • Measure and report the total execution time of both approaches, and briefly analyze the difference in performance.

Evaluation ⚖️

Your work will be evaluated based on:

• Thread Management: Correct use of start() and join().
• Simulation Logic: Correct implementation of the loops and random delays in the worker threads.
• Thread Safety: Following the constraint of each worker only writing to its own assigned object.
• Code Quality: Readable code and proper use of Java conventions.

Total: 500 points

• 🧠 Theoretical Questions – 150 points
• 💻 Practical Task (Download Manager) – 350 points

Submission ⌛

1. Add your mentor as a contributor to the project.
2. Create a develop branch for implementing features.
3. Use Git for regular code commits.
4. Push your code and the answers file (Report.md) to the remote repository.
5. Submit a pull request to merge the develop branch with main.

Deadline: Friday, June 5 (15th of Khordad)

Additional Resources 📚

• Java Concurrency and Multithreading
• Creating and Starting Java Threads
• Thread.join() explained