1. Definitions Process – An executing program
Thread – A path of execution through a process. A single process can concurrently execute many threads.
Concurrent programming – Code that executes multiple algorithms at a time
Critical Section – A resource or area of code that must be protected from unlimited simultaneous access by multiple threads.
Mutual Exclusion – The mechanism for protecting a critical section.
Monitor – A language construct in Java that utilizes the synchronized reserved word to enforces mutual exclusion.

2. Examples of Concurrency
Note: Each thread has its own sequence of instructions
JVM
Interpreted instructions in a Java application or applet
Garbage Collection reclaiming memory of unused objects
GUI Listeners that respond to user or program events
Operating System
Respond to interrupts
Schedule execution among processes based on a quantum or priority

3. Implementing a thread in Java
Signature line: There are two alternatives:
Add implements Runnable to the JFrame or Applet class signature line .
Create a class that extends Thread.
Program a run method (public void run() {})
Reference and instantiate the thread
Thread thread = new Thread(this, "name");
thread = new Thread(new ThreadClass(), "name");
Start the thread (thread.start()).
The thread ends when it returns from the run method.

4. Thread Example Assumption: round robin scheduling algorithm
public class NumberThread extends Thread
{ private int num;
public NumberThread(int num) {this.num=num;}
public void run()
{ for (int k=0; i<5; k++){System.out.println(num);} }
public static void main(String[] args)
{ for (int t=1; t<=5; t++)
new NumberThread(t).start();
Sample Output:
Note: The order of execution depends on operating system scheduling

5. Other Thread Methods Name of thread: getName(), setName(String name)
Thread Priority: getPriority(), setPriority()
Give up control: sleep(long milliseconds), yield()
Wait for thread to die: join(), join(long milliseconds)
Get object of current thread: currentThread()
See if thread is alive: isAlive()
See if thread interrupted: isInterrupted()
Preemption: Higher priority threads will run before lower priorities

6. Thread Execution
Thread that run continuously consume all of the CPU cycles in the computer. Threads should suspend themselves during execution.
Example of a run method
public void run()
{ Thread myThread = Thread.currentThread();
while (clockThread == myThread)
{ repaint();
try { Thread.sleep(1000); }
catch (InteruptedException e) { }
} }

7. Critical Sections and Mutual Exclusion
Only one synchronized method of a class can execute at a time
Critical Section: A group of instructions that will fail if the number of concurrent threads executing it is not limited
Mutual Exclusion: The technique that enforces a critical section
Examples: semiphores, condition variables, monitors
Java uses monitors
The Producer/Consumer, Reader/Writer, and Dining Philosopher are classical computer science problems used to illustrate critical sections and mutual exclusion
Our text has a producer consumer example
We'll briefly discuss the reader/writer problem in class
Lab 8 implements the dining philosopher problem

8. Monitors A mutual exclusion technique built into the language syntax
Illustration
In a barbershop, people wait for the barber chair
those waiting make a mad dash to the chair when it is free
No assumptions can be made as to who wins
Java
Every object is a monitor with a lock flag (i.e. barber chair)
Only one thread can have ('acquire') the lock
Java uses the synchronized modifier for this purpose.
Acquire a lock: synchronized(object) { // critical section }
Example
private synchronized int add(int a) {x = 3; x += b; return x;}
Only one thread can execute an object's synchronized method.
Results are unpredictable if we leave off the synchronized modifier

9. Thread States Ready: A thread is OK to execute
Run: The thread is executing. If it's quantum runs out or a higher priority thread becomes ready, Java will switch to another thread if possible
Wait: A thread cannot execute until another thread notifies
Block: I/O must complete for thread to go to ready
Dead: run method finished
Sleep: thread called sleep(). It must be interrupted to continue
Ready
Run
Block
Sleep
Wait
Dead
State Diagram

10. Object Class Monitor Methods
wait() – Move this thread to the wait state
notify() – Move one waiting thread from the wait to ready state. The programmer has no control over which thread gets chosen
notifyAll() – Move all waitig threads from the wait to the ready state.

11. Lab Assignment Dining Philosopher Problem Five philosophers
Requires two chopsticks to eat
Alternates between eat, think, hungry, famished, and starve
Never puts down a chopstick until finishes eating
Starve
Eat
Think
Famished
Hungry
State Diagram
Implementation hints
Instantiate philosopher array of five threads
Instantiate array of five chopsticks

12. Dining Philosopher Illustrates:
Deadlock: The application cannot continue because it gets into a state where resources cannot be released or obtained
Starvation: Some threads never get a chance to execute
Critical Section: The program must limit the number of threads executing a part of an algorithm
Idempotent Operations
Operations that can be repeated many times without harm
A pickUp method allows a philosopher to pick up a chopstick that they already own without harm.