Multi-thread

General info

• A thread -- a virtual CPU.
• Thread components.
• Create a thread.
• Thread issue.
• Multi-thread.
• Object lock flag.
• Dead lock.
• Thread interaction.

Return to top

Thread components

• CPU
• Code
• Data
• Controlling the code and data that are used by that thread

Return to top

Create a thread

• extends Thread class or
• implements Runnable interface
• Start a thread, using start() method or placing a thread in a runnable state

Return to top

Thread issue

• Control the execution of a thread and write platform independent code with threads
• Describe the difficulties that might arise when multiple threads share data
• Use wait() and notify() to communicate beween threads

Return to top

Multi-thread

• Multiple threads from the same Runnable instance
• Threads share the same data and code
• Use synchronized keyword to protect data from corruption
• Use Thread.sleep(N) to schedule a thread, but not guaranteed.
• Test threads: use isAlive()
• Put threads on hold: use sleep(), join()

Return to top

Object lock flag

• Every object has a flag that can be thought of as a "lock flag"
• synchronized allows interaction with the lock flag
  • All access to delicate data should be synchronized.
  • Delicate data protected by synchronized should be private.
  • The following two code segments are equivalent:

    public void push(char c) {
        synchronized(this) {
            ....		
        }
    }
    public synchronized void push(char c) {
        ....	
    }
    

• Releasing the Lock Flag
  • Released when the thread passes the end of the synchronized() code block
  • Automatically released when a break or exception is thrown by the synchronized() code block
  <

  Return to top /ul>

  Deadlock

  • Is two threads, each waiting for a lock from the other
  • Is not detected or avoided
  • Can be avoided by:
    • Deciding on the order to obtain locks
    • Adhering to this order throughout
    • Releasing locks in reverse order

  Return to top

  Thread Interaction – wait()and notify()

  • Scenario: Consider yourself and a cab driver as two threads
    --The problem: How to determine when you are at your destination
    --The solution: You notify the cabbie of your destination and relax Cabbie drives and notifies you upon arrival at yourdestination
  • wait() and notify()
  • The pools: Wait pool, Lock pool
  • Monitor Model for synchronization:
    • Leave shared data in a consistent state
    • Ensure programs cannot deadlock
    • Do not put threads expecting different notifications in the same wait pool
  • Example:

    public class SyncStack {
        private Vector buffer = new Vector(400, 200);
    
    //communication of two
        public synchronized char pop() {
     	char c;
     	while (buffer.size() == 0) {
     	    try {
     		this.wait();
     	    } catch (InterruptedException e) {
     	    // ignore it...
     	    }
     	}
     	c = ((Character)buffer.remove(buffer.size()-1)).charValue();
     	return c;
        }
    
        public synchronized void push(char c) {
    	this.notify();
    	Character charObj = new Character(c);
     	buffer.addElement(charObj);
        }
    

  • Use wait()/notifyAll() to replace suspend(), resume(), stop()
  • A proper control example, provided by Sun education:

    public class ControlledThread extends Thread {
        static final int SUSP = 1;
        static final int STOP = 2;
        static final int RUN = 0;
        private int state = RUN;
    
        public synchronized void setState(int s) {
            state = s;
            if ( s == RUN ) {
                 notify();
            }
        }
    
        public synchronized boolean checkState() {
            while ( state == SUSP ) {
                 try {
                     wait();
                 } catch (InterruptedException e) {
                   // ignore
                 }
           }
           if ( state == STOP ) {
               return false;
           }
           return true;
        }
    
        public void run() {
            while ( true ) {
              // doSomething();
    
              // Be sure shared data is in consistent state in
              // case the thread is waited or marked for exiting
              // from run()
                if ( !checkState() ) {
                    break;
                }
            }
       }
    }