blockable.java

char33-1 堵塞状态 提供了本书第3章的堵塞状态实例的源程序

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;

////////////基本的框架///////////
class Blockable extends Thread {
  private Peeker peeker;
//构建文本区域
  protected JTextField state = new JTextField(30);
  protected int i;
  public Blockable(Container c) {
    c.add(state);
    peeker = new Peeker(this, c);
  }
//synchronized关键字用来表明此方法为关键函数
  public synchronized int read() { return i; }
  protected synchronized void update() {
    state.setText(getClass().getName()
      + " state: i = " + i);
  }
  public void stopPeeker() { 
    // peeker.stop(); Deprecated in Java 1.2
//推荐采用的方法
peeker.terminate();
}
}
class Peeker extends Thread {
  private Blockable b;
  private int session;
  private JTextField status = new JTextField(30);
  private boolean stop = false;
  public Peeker(Blockable b, Container c) {
    c.add(status);
    this.b = b;
    start();
  }
  public void terminate() { stop = true; }
  public void run() {
    while (!stop) {
      status.setText(b.getClass().getName()
        + " Peeker " + (++session)
        + "; value = " + b.read());
       try {
        sleep(100);
      } catch(InterruptedException e) {
        System.err.println("Interrupted");
      }
    }
  }
}
///////////// 通过调用sleep()函数来挂起线程 ///////////
class Sleeper1 extends Blockable {
	public Sleeper1(Container c) { super(c); }
	public synchronized void run() {
		while(true) {
			i++;
			update();
			try {
				sleep(1000);
			} catch(InterruptedException e) {
				System.err.println("Interrupted");
			}
		}
	}
}

class Sleeper2 extends Blockable {
	public Sleeper2(Container c) { super(c); }
	public void run() {
		while(true) {
			change();
			try {
				sleep(1000);
			} catch(InterruptedException e) {
				System.err.println("Interrupted");
			}
		}
	}
	public synchronized void change() {
		i++;
		update();
	}
} ///:Continued
///:Continuing
///////////  通过调用suspend()来挂起线程 ///////////
class SuspendResume extends Blockable {
public SuspendResume(Container c) {
super(c);    
new Resumer(this); 
}
}

class SuspendResume1 extends SuspendResume {
public SuspendResume1(Container c) { super(c);}
public synchronized void run() {
while(true) {
i++;
update();
suspend(); // Java 1.2中不被推荐使用
}
}
}

class SuspendResume2 extends SuspendResume {
public SuspendResume2(Container c) { super(c);}
public void run() {
while(true) {
change();
suspend(); // Java 1.2中不被推荐使用
}
}
public synchronized void change() {
i++;
update();
}
}

class Resumer extends Thread {
private SuspendResume sr;
public Resumer(SuspendResume sr) {
this.sr = sr;
start();
}
public void run() {
while(true) {
try {
sleep(1000);
} catch(InterruptedException e) {
System.err.println("Interrupted");
}
sr.resume(); // Java 1.2中不被推荐使用
}
}
} 
//synchronized(wn2) {
	//  wn2.notify();
	//}
class WaitNotify1 extends Blockable {
	public WaitNotify1(Container c) { super(c); }
	public synchronized void run() {
		while(true) {
			i++;
			update();
			try {
				wait(1000);
			} catch(InterruptedException e) {
				System.err.println("Interrupted");
			}
		}
	}
}

class WaitNotify2 extends Blockable {
	public WaitNotify2(Container c) {
		super(c);
		new Notifier(this); 
	}
	public synchronized void run() {
		while(true) {
			i++;
			update();
			try {
				wait();
			} catch(InterruptedException e) {
				System.err.println("Interrupted");
			}
		}
	}
}

class Notifier extends Thread {
	private WaitNotify2 wn2;
	public Notifier(WaitNotify2 wn2) {
		this.wn2 = wn2;
		start();
	}
	public void run() {
		while(true) {
			try {
				sleep(2000);
			} catch(InterruptedException e) {
				System.err.println("Interrupted");
			}
			synchronized(wn2) {
				wn2.notify();
			}
		}
	}
} 
class Sender extends Blockable { // 发送类
	private Writer out;
	public Sender(Container c, Writer out) { 
		super(c);
		this.out = out; 
	}
	public void run() {
		while(true) {
			for(char c = 'A'; c <= 'z'; c++) {
				try {
					i++;
					out.write(c);
					state.setText("Sender sent: " 
						+ (char)c);
					sleep((int)(3000 * Math.random()));
				} catch(InterruptedException e) {
					System.err.println("Interrupted");
				} catch(IOException e) {
					System.err.println("IO problem");
				}
			}
		}
	}
}

class Receiver extends Blockable {
	private Reader in;
	public Receiver(Container c, Reader in) { 
		super(c);
		this.in = in; 
	}
	public void run() {
		try {
			while(true) {
				i++; // 表明此线程还存在
				// 直到有字符出现，才重新启动线程
				state.setText("Receiver read: "
					+ (char)in.read());
			}
		} catch(IOException e) {
			System.err.println("IO problem");
		}
	}
} 
class Blocking extends JApplet {
//	设置开始的按纽
		private JButton 
			start = new JButton("Start"),
			stopPeekers = new JButton("Stop Peekers");
		private boolean started = false;
		private Blockable[] b;
		private PipedWriter out;
		private PipedReader in;
		class StartL implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				if(!started) {
					started = true;
					for(int i = 0; i < b.length; i++)
						b[i].start();
				}
			}
		}
		class StopPeekersL implements ActionListener {
			public void actionPerformed(ActionEvent e) {
				// 另一种取代Thread.stop()的方式
				for(int i = 0; i < b.length; i++)
					b[i].stopPeeker();
			}
		}
		public void init() {
			Container cp = getContentPane();
			cp.setLayout(new FlowLayout());
			out = new PipedWriter();
			try {
				in = new PipedReader(out);
			} catch(IOException e) {
				System.err.println("PipedReader problem");
			}
			b = new Blockable[] {
				new Sleeper1(cp),
					new Sleeper2(cp),
					new SuspendResume1(cp),
					new SuspendResume2(cp),
					new WaitNotify1(cp),
					new WaitNotify2(cp),
					new Sender(cp, out),
					new Receiver(cp, in)
			};
			start.addActionListener(new StartL());
			cp.add(start);
			stopPeekers.addActionListener(
				new StopPeekersL());
			cp.add(stopPeekers);
		}
		public static void main(String[] args) {
			Console.run(new Blocking(), 350, 550);
		}
	}