at-m42:lecture9
Differences
This shows you the differences between two versions of the page.
Both sides previous revisionPrevious revisionNext revision | Previous revision | ||
at-m42:lecture9 [2009/04/15 17:18] – eechris | at-m42:lecture9 [2011/01/14 12:45] (current) – external edit 127.0.0.1 | ||
---|---|---|---|
Line 468: | Line 468: | ||
{{ : | {{ : | ||
+ | {{ : | ||
* Picking up where it left off | * Picking up where it left off | ||
- Set the '' | - Set the '' | ||
- Now '' | - Now '' | ||
- | - Return the key | + | - **Return the key** |
===== Thread B is selected to run ===== | ===== Thread B is selected to run ===== | ||
{{ : | {{ : | ||
+ | {{ : | ||
* '' | * '' | ||
- The method is '' | - The method is '' | ||
- | - The key is available, get the key | + | - The **key is available, get the key** |
- Put the value of '' | - Put the value of '' | ||
- Balance is 2, so '' | - Balance is 2, so '' | ||
- Set the '' | - Set the '' | ||
- Now '' | - Now '' | ||
- | - Return the key | + | - **Return the key** |
===== Synchronizing on other resources ===== | ===== Synchronizing on other resources ===== | ||
- | Synchronizing on something other than the memory inside an object | + | * Synchronizing on something other than the memory inside an object |
- | Using non-synchronized objects | + | |
- | Best to wrap everything inside an object and guard it with the object’s own synchronized methods, but you can also: | + | |
+ | synchronized(syncObject) { | ||
+ | | ||
+ | | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | ===== Blocking ===== | ||
- | Blocking | ||
Four states of a thread: | Four states of a thread: | ||
- | 1. New: the thread object has been created but it hasn’t been started yet so it cannot run | + | - //New//: the thread object has been created but it hasn’t been started yet so it cannot run |
- | 2. Runnable: thread can be run, when the time-slicing mechanism has CPU cycles available | + | - //Runnable//: thread can be run, when the time-slicing mechanism has CPU cycles available |
- | 3. Dead: normally after thread returns from its run( ) | + | - //Dead//: normally after thread returns from its '' |
- | 4. Blocked: the thread could be run but there’s something that prevent it. While a thread is in the blocked state the scheduler will simply skip over it and not give it any CPU time | + | - //Blocked//: the thread could be run but there’s something that prevent it. While a thread is in the blocked state the scheduler will simply skip over it and not give it any CPU time |
- | Becoming Blocked | + | ===== Becoming Blocked |
- | Thread is sleeping: sleep(milliseconds) | + | |
- | Thread is suspended: suspend( ). It will not become runnable again until the thread gets the resume( ) message | + | |
- | Thread is waiting with wait( ). It will not become runnable again until the thread gets the notify( ) or notifyAll( ) message | + | |
- | The thread is waiting for some IO to complete | + | |
- | The thread is trying to call a synchronized method on another object and that object’s lock is not available | + | |
- | Deadlock | + | |
- | A chain of threads waiting on each other, looping back to the beginning | + | |
- | No language support to prevent it | + | |
- | Tough to debug | + | |
- | To create a deadlock only need two threads and two objects | + | |
- | Thread deadlock | + | |
- | Thread deadlock scenario | + | |
- | Thread A enters synchronized method of object foo and gets the key. | + | |
- | Thread A goes to sleep | + | |
- | Thread deadlock scenario | + | |
- | Thread B enters synchronized method of object bar and gets the key. | + | |
- | Thread B tries to enter a synchronized method of object foo, but can't get that key (A has it). | + | |
- | B " | + | |
- | B keeps the bar key. | + | |
- | Thread deadlock scenario | + | |
- | Thread A wakes up and tries to enter a synchronized method on object bar., but can't get that key because B has it. | + | |
- | A " | + | |
- | Thread A can't run until it get's bar key that B is holding. | + | |
- | Thread B can't run until it gets the foo key that A is holding. | + | |
- | Deadlock! | + | |
- | Summary | + | |
- | Single-threaded programming: | + | |
- | Multithreading: | + | |
- | Multithreading makes Java complicated, | + | |
- | Lab Exercises | + | |
- | 1. Inherit a class from Thread and override the run( ) method. Inside run( ), print a message, then call sleep( ). Repeat this 3 times, then return from run( ). Put a start-up message in the constructor and override finalize( ) to print a shut-down message. Make a separate thread class that calls System.gc( ) inside run( ), printing a message as it does so. Make several thread objects of both types and run them to see what happens. | + | |
- | 2. Create two Thread classes, one with a run( ) that starts up, creates and passes its own handle to an object of the second thread class and then calls wait( ). The other classes’ run( ) should cause a notifyAll( ) in the first thread after some number of seconds have passed, so the first thread can print out a message. | + | |
- | {{:at-m42:deposit.png|}} | + | * Thread is // |
+ | * Thread is // | ||
+ | * Thread is //waiting// with '' | ||
+ | * The thread is waiting for some I/O to complete. | ||
+ | * The thread is trying to call a '' | ||
- | ===== Heading 1 ===== | + | ===== Deadlock |
- | <code groovy 1 | Example 1: Everything is an object (at-m42/ | + | * A chain of threads waiting on each other, looping back to the beginning |
- | extern> http:// | + | * No language support to prevent it |
- | </ | + | * Tough to debug |
- | ---- | + | * To create a deadlock only need two threads and two objects |
+ | |||
+ | ===== Thread deadlock ===== | ||
- | Notes ... | + | {{: |
- | ===== Heading 2 ===== | + | ===== Thread deadlock scenario |
- | * [[#Sub head 1]] | + | {{: |
- | * [[#Sub head 2]] | + | |
+ | * '' | ||
+ | * '' | ||
- | ===== Summary of this Lecture | + | ===== Thread deadlock scenario ===== |
- | + | ||
- | The .... | + | |
+ | {{: | ||
- | * [[#Heading 1]] | + | * '' |
- | * [[#Heading 2]] | + | * '' |
- | * [[#heading 3]] | + | * B " |
+ | * B keeps the '' | ||
- | ===== Lab Exercises | + | ===== Thread deadlock scenario |
+ | {{: | ||
+ | * '' | ||
+ | * A " | ||
+ | * '' | ||
+ | * Thread B can't run until it gets the '' | ||
+ | * **Deadlock!** | ||
- | | + | ===== Summary ===== |
+ | | ||
+ | * Multi-threading: suddenly you can have collisions and destroy information, | ||
+ | * Multi-threading makes programming on the Java Platform complicated. | ||
+ | * Groovy multithreading easier because of the use of the closure. | ||
+ | * **Multi-threading is hard**! | ||
---- | ---- |
at-m42/lecture9.1239815917.txt.gz · Last modified: 2011/01/14 12:26 (external edit)