1 / 24

Project 2 Overview (Threads in Practice)

Project 2 Overview (Threads in Practice). CSE451 Andrew Whitaker. Project 2 Overview. Project consists of threaded Java programs No VMWare / kernel hacking You can use any multi-processor Linux machine Most (all?) undergrad lab machines are dual core

meris
Download Presentation

Project 2 Overview (Threads in Practice)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Project 2 Overview(Threads in Practice) CSE451 Andrew Whitaker

  2. Project 2 Overview • Project consists of threaded Java programs • No VMWare / kernel hacking • You can use any multi-processor Linux machine • Most (all?) undergrad lab machines are dual core • Also, you have access to amlia.cs.washington.edu • Run ‘more /proc/cpuinfo’ to verify • Continue to work in your project teams

  3. General Instructions • Your programs must use proper synchronization • Working functionality is not enough! • Remember the rules we’ve talked about: • All shared, mutable state must be properly synchronized • Usually with a synchronized block or method • Compound actions must be protected by a single lock • Start early! • Not a huge amount of code, but a lot of new concepts • Thursday’s discussion will be Q & A

  4. Using Other People’s Code • Do it! • e.g., java.util.LinkedList, java.util.ArrayList, … • But, understand the implications for threading • May require documentation diving

  5. Part 1: Implementing Semaphores • Semaphore is a thread-safe integer • Supports up and down operations for increment / decrement • The semaphore can never go negative • If value == 0, then down blocks before decrementing • Thread is added to a wait queue • If value == 0, then up wakes up a thread after incrementing • Semaphore with value 1 is a lock

  6. Pseudocode publicclass Semaphore { private int count; // block if count == 0 // else, decrement publicvoid down () { } // increment count // wake up somebody (if necessary) publicvoid up () { } }

  7. Semaphores, Continued • Condition variables and semaphores have equivalent expressive power • One can be implemented with the other • Your task: demonstrate this with Java code • Your solution should not busy wait • Do not use java.util.concurrent.Semaphore • Or any other off-the-shelf semaphore implementation

  8. Part 2: Calculating  • Step 1: approximate  using a random number generator • Step 2: Convert this program to a multi-threaded program • Step 3: Benchmark the program with a variable number of threads

  9.  Approximation Hint • Consider a circle inscribed in a square • Imagine throwing a large number of darts at the square • Some fraction of darts will also hit the circle • Use this fraction to calculate 

  10. Multi-threaded  Calculator • Approximating  requires many samples • 10s of millions is a reasonable starting point • So, let’s try decomposing the work across multiple threads public double calculate(int numSamples, int numThreads) { return 0.0; // TODO: implement this! }

  11. Mapping This to Code • Java’s Thread join method is useful for these sorts of computations public double calculate(int numSamples, int numThreads) { Thread [] threads = new Thread[numThreads]; for (int i=0;i <= numThreads; i++) { threads[i] = new WorkerThread(…); threads[i].start(); } for (int i=0;i <= numThreads; i++) { try { threads[i].join(); // wait for thread termination } catch (InterruptedException ie) {} //ignored } }

  12. Benchmarking • Create a graph with # threads on the x-axis and latency on the y-axis • Let threads range from 1 to 10 • Number of samples should be fixed • Each thread does a fraction of the total samples • Measure latency with System.currentTimeMillis()

  13. Part 3: Multi-threaded Web Server • Task: convert a single-threaded web server to a multi-threaded web server • Why? • Any high-throughput web server must handle multiple requests in parallel • By default, each thread handles one request at a time • Requests are blocking • Thread is stalled while waiting for network, disk, etc.

  14. These are blocking calls Anatomy of a (Single-threaded) Web Server • Accept a new Socket • Read from socket to extract request URI (e.g., index.html) • Read desired file into a buffer • Write file over the socket • Close the socket while (true) { }

  15. Possible Alternate Approach: Thread-per-request while (true) { • Accept a new Socket • Fork a thread } Read from socket Read desired file into a buffer Write file over the socket Close the socket Thread exits

  16. Analysis of Thread-per-Request • Advantage: supports simultaneous requests (and higher throughput) • Blocking operations only stall one thread • Disadvantages: • Thread creation is expensive • Must create PCB, allocate stack • Thread teardown is expensive • Too many threads can lead to poor performance

  17. Preferred Solution: Thread Pool • On startup, create a static pool of worker threads • Each thread loops forever, processing requests • Advantages: • Thread allocation cost is paid only once • Threads are never deallocated

  18. Thread Pool, Implementation Overview while (true) { • Accept a new Socket • Enqueue Socket while (true) { } Dequeue Socket Read from socket Read desired file into a buffer Write file over the socket Close the socket Accept thread } Worker threads

  19. Web Server, Continued • Step 2: Add a “statistics” page at http://hostname/STATS • Req/sec over the previous ten seconds • Number of currently active threads • Number of idle threads • Step 3: Benchmark the web server • Using the provided benchmark tool

  20. Java Timers • See lecture or condition variables • OR, java.util.Timer and java.util.TimerTask • Key point: timers run in a separate thread • So, shared state must be properly synchronized

  21. Part 4: GUI Hacking • We provide a simple GUI for calculating the first N fibonacci numbers • You provide an implementation of the cancel button

  22. Challenge • Problem: GUI frameworks are single-threaded • Long-lived computations can make the GUI unresponsive • Solution: Transfer long-lived tasks to a separate thread • Requires coordination between the GUI thread and the helper thread

  23. Things You Need to Understand • How task handoff works in the Swing GUI framework? • In particular, SwingUtilities.invokeLater • How does thread interruption work? • Via Thread.interrupt

  24. Thread Interruption • You can call interrupt on any Thread • What happens? • If the thread was blocked, it receives an InterruptedException • If the thread is ready or running, it has an interrupted flag set • The thread must explicitly check this flag with Thread.isInterrupted

More Related