JAVA范例 十三）多线程编程（3）

      线程应用实例

　　实例244 下雪的村庄

package Chapter17;

import java.applet.Applet;
import java.awt.*;
import java.util.Random;

public class SnowVillage extends Applet implements Runnable {

	Thread thread;// 声明主线程

	Image off, images[];// 声明图片对象和图片数组

	Random random;// 声明一个随机数对象

	int flag, sonwNum, wind, thread_1, size;// 声明一些int型变量

	int[] X, Y;// 声明两个int型数组，分别表示X和Y坐标点

	long time = 0;// 表示时间

	Dimension ds;// 声明一个Dimension对象

	MediaTracker mt;// 声明一个MediaTracker对象

	int getValue(String s1, int s2, int max, int min) {// 获取HTML标记中命名参数的值

		String s = getParameter(s1);
		if (s != null) {

			if ((s2 = Integer.parseInt(s)) > max)
				return max;
			else if (s2 < min)
				return min;
			else
				return s2;

		} else
			return s2;

	}

	public void init() {// Applet小程序初始化
		this.setSize(300, 200);
		random = new Random();
		ds = getSize();
		off = createImage(ds.width, ds.height);// 创建一个图象
		sonwNum = getValue("sonwNum", 100, 500, 0);// 获取雪片的个数
		size = getValue("size", 3, 10, 3);// 获取雪片的大小
		thread_1 = getValue("threadsleep", 80, 1000, 10);// 获取休眠的时间
		// 获取绘制雪片的XY坐标值
		X = new int[sonwNum];
		Y = new int[sonwNum];
		for (int i = 0; i < sonwNum; i++) {

			X[i] = random.nextInt() % (ds.width / 2) + ds.width / 2;
			Y[i] = random.nextInt() % (ds.height / 2) + ds.height / 2;

		}

		mt = new MediaTracker(this);
		images = new Image[1];
		images[0] = getImage(getDocumentBase(), "xue.jpg");
		mt.addImage(images[0], 0);
		try {

			mt.waitForID(0);

		} catch (InterruptedException _ex) {
			return;
		}
		flag = 0;

	}

	public void start() {// 启动小程序

		if (thread == null) {

			thread = new Thread(this);
			thread.start();// 启动线程

		}

	}

	public void stop() {// 停止运行小程序

		thread = null;

	}

	public void run() {// 运行线程

		while (thread != null) {

			try {

				Thread.sleep(thread_1);

			} catch (InterruptedException _ex) {
				return;
			}
			repaint();

		}

	}

	public void snow(Graphics g) {// 绘制雪片

		g.setColor(Color.white);
		for (int i = 0; i < sonwNum; i++) {

			g.fillOval(X[i], Y[i], size, size);
			X[i] += random.nextInt() % 2 + wind;
			Y[i] += (random.nextInt() % 6 + 5) / 5 + 1;
			if (X[i] >= ds.width)
				X[i] = 0;
			if (X[i] < 0)
				X[i] = ds.width - 1;
			if (Y[i] >= ds.height || Y[i] < 0) {

				X[i] = Math.abs(random.nextInt() % ds.width);
				Y[i] = 0;

			}

		}

		wind = random.nextInt() % 5 - 2;

	}

	public void paint(Graphics g) {// 绘制组件

		off.getGraphics().setColor(Color.black);
		off.getGraphics().fillRect(0, 0, ds.width, ds.height);
		off.getGraphics().drawImage(images[0], 0, 0, this);
		snow(off.getGraphics());
		g.drawImage(off, 0, 0, null);

	}

	public void update(Graphics g) {// 重新绘制组件

		paint(g);

	}

}

 

　　实例245 小飞侠

package Chapter17.example;

import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;

public class SplitLine extends Applet implements Runnable {
	private Image moveleft__1, moveright_1, moveleft_2, moveright_2, temp;// 声明Image对象
	private Image image;//
	private Graphics graphics;
	private Thread thread = null;
	private MediaTracker img_tracker;
	private int height, width;
	public void init() {// 初始化Applet小程序
		// 创建Image对象
		moveright_1 = getImage(getDocumentBase(), "3.jpg");
		moveright_2 = getImage(getDocumentBase(), "4.jpg");
		moveleft__1 = getImage(getDocumentBase(), "1.jpg");
		moveleft_2 = getImage(getDocumentBase(), "2.jpg");
		// 创建MediaTracker对象
		img_tracker = new MediaTracker(this);
		// 将图片对象加载到媒体跟踪器中
		img_tracker.addImage(moveright_1, 0);
		img_tracker.addImage(moveleft__1, 0);
		img_tracker.addImage(moveright_2, 0);
		img_tracker.addImage(moveleft_2, 0);
		// 获取Applet的长和宽
		width = this.size().width;
		height = this.size().height;
		try {
			img_tracker.waitForID(0);// 跟踪指定ID的图象
		} catch (InterruptedException e) {
		}
		// 创建图象区
		image = createImage(width, height);
		// 创建Graphics对象
		graphics = image.getGraphics();
	}
	public void start() {// Applet小程序的start方法
		if (thread == null) {
			thread = new Thread(this);
			thread.start();// 开始运行线程
		}
	}
	public void run() {// 线程的run方法
		Color fg = this.getForeground();
		int imgWidth, imageHeight, x = 0, y = 0;
		boolean forward = true;
		imgWidth = moveright_1.getWidth(this);
		imageHeight = moveright_1.getHeight(this);
		y = (height - imageHeight) / 2;
		fg = Color.blue;// 设置分割线的颜色
		try {
			while (thread != null) {
				thread.sleep(200);
				if (forward) {
					x += 15;
					if ((x % 2) == 1) {
						temp = moveright_1;
					} else {
						temp = moveright_2;
					}
					if (x >= (width - imgWidth)) {
						forward = false;
					}
				} else {
					x -= 15;
					if ((x % 2) == 1) {
						temp = moveleft__1;
					} else {
						temp = moveleft_2;
					}
					if (x == 0) {
						forward = true;
					}
				}
				graphics.setColor(Color.white);// 设置小程序的背景颜色
				graphics.fillRect(0, 0, width, height);
				graphics.setColor(fg.brighter().darker());
				graphics.drawLine(0, (height - imageHeight) / 2 + imageHeight,
						width, (height - imageHeight) / 2 + imageHeight);
				graphics.setColor(fg.darker().brighter());
				graphics.drawLine(0, (height - imageHeight) / 2 + imageHeight,
						width, (height - imageHeight) / 2 + imageHeight);
				graphics.drawImage(temp, x, y, this);
				repaint();
			}
		} catch (InterruptedException e) {
		}
	}
	public void update(Graphics g) {
		paint(g);
	}
	public void paint(Graphics g) {
		g.drawImage(image, 0, 0, this);
	}
}

 

　　实例246 飞流直下

package Chapter17.status;

import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;

public class Faucet extends Applet implements Runnable {
	final int Max = 1000;// 水滴的最大个数
	Drop d[];// 声明一个水滴对象
	int width, height, X, Y;// 声明Applet小程序的宽和高，及以XY坐标中心
	Image off;// 声明一个图片对象
	Graphics graphics;// 声明一个Graphics对象
	Thread thread;// 声明一个线程对象
	public void init() {// Applet小程序初始化
		this.setSize(300, 200);
		setBackground(Color.gray);
		width = getSize().width;
		height = getSize().height;
		d = new Drop[Max];
		for (int i = 0; i < Max; i++)
			d[i] = new Drop();
		off = createImage(width, height);
		graphics = off.getGraphics();
	}
	public void start() {// 开始执行小程序
		thread = new Thread(this);
		thread.start();
	}
	public void stop() {// 停止执行小程序
		thread = null;
	}
	public void update(Graphics g) {// 重新绘制小程序
		paint(g);
	}
	public void paint(Graphics g) {// 绘制组件
		g.drawImage(off, 0, 0, this);
	}
	public void run() {// 运行线程
		boolean reset = false;
		int i, t = 0;
		while (true) {
			graphics.clearRect(0, 0, width, height);
			graphics.setColor(Color.white);
			graphics.drawLine(0, 15, 10, 15);
			for (i = 0; i < Max; i++) {
				graphics.fillOval((int) d[i].X, (int) d[i].Y, 3, 3);
				d[i].X = d[i].X + d[i].newX;
				if (d[i].X > 10) {
					d[i].Y += d[i].newY * d[i].time / 1000;
					d[i].newY = (int) 9.8 * d[i].time;
					d[i].time++;
				}
				if (d[i].Y > height) {
					d[i].reset();
				}
			}
			repaint();
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
			}
		}
	}
}
class Drop {// 水滴类
	double X, Y;
	double newX, newY;
	int time;
	public Drop() {
		reset();
	}
	public void reset() {// 重新设置绘制水滴的位置和大小
		X = (int) (Math.random() * -40);
		Y = (int) (Math.random() * 5 + 10);
		newX = Math.random() * 3 + 1.0;
		newY = 0;
		time = 0;
	}
}

 

　　实例247 多线程断点续传

package Chapter17.download;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.net.HttpURLConnection;
import java.net.URL;

//Java实现网络文件传输,在客户端请求Web服务器传输指定文件，并将文件保存。
public class ResumeUpload {
	private String downSource = "http://kent.dl.sourceforge.net/sourceforge/jamper/Sample.zip"; // 定义Web地址和文件名
	private String savePath = "d:\\temp"; // 定义存文件路径
	private String saveName = "汉仪YY字体.zip"; // 定义文件名
	public ResumeUpload() {
		try {
			FileInfo bean = new FileInfo(downSource, savePath, saveName, 5);
			FTPthread fileFetch = new FTPthread(bean);
			fileFetch.start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {
		new ResumeUpload();
	}
}
class FTPthread extends Thread { // 传输文件线程类
	FileInfo siteInfoBean = null; // 文件信息Bean
	long[] nPos;
	long[] startPos; // 开始位置
	long[] endPos; // 结束位置
	FilePart[] fileSplitterFetch; // 子线程对象
	long nFileLength; // 文件长度
	boolean bFirst = true; // 是否第一次取文件
	boolean bStop = false; // 停止标志
	File tmpFile; // 文件传输临时信息
	DataOutputStream output; // 输出到文件的输出流
	public FTPthread(FileInfo bean) throws IOException {
		siteInfoBean = bean;
		tmpFile = new File(bean.getSFilePath() + File.separator
				+ bean.getSFileName() + ".info");
		if (tmpFile.exists()) {
			bFirst = false;
			readInform();
		} else {
			startPos = new long[bean.getNSplitter()];
			endPos = new long[bean.getNSplitter()];
		}
	}
	public void run() {
		// 获得文件长度
		// 分割文件
		// 实例PartCacth
		// 启动PartCacth线程
		// 等待子线程返回
		try {
			if (bFirst) {
				nFileLength = getFileSize();
				if (nFileLength == -1) {
					System.err.println("File Length is not known!");
				} else if (nFileLength == -2) {
					System.err.println("File is not access!");
				} else {
					for (int i = 0; i < startPos.length; i++) {
						startPos[i] = (long) (i * (nFileLength / startPos.length));
					}
					for (int i = 0; i < endPos.length - 1; i++) {
						endPos[i] = startPos[i + 1];
					}
					endPos[endPos.length - 1] = nFileLength;
				}
			}
			// 启动子线程
			fileSplitterFetch = new FilePart[startPos.length];
			for (int i = 0; i < startPos.length; i++) {
				fileSplitterFetch[i] = new FilePart(siteInfoBean.getSSiteURL(),
						siteInfoBean.getSFilePath() + File.separator
								+ siteInfoBean.getSFileName(), startPos[i],
						endPos[i], i);
				AddInform.log("Thread " + i + " , 开始位置 = " + startPos[i]
						+ ", 结束位置 = " + endPos[i]);
				fileSplitterFetch[i].start();
			}
			// 等待子线程结束
			// int count = 0;
			// 是否结束while循环
			boolean breakWhile = false;
			while (!bStop) {
				writeInform();
				AddInform.sleep(500);
				breakWhile = true;
				for (int i = 0; i < startPos.length; i++) {
					if (!fileSplitterFetch[i].bDownOver) {
						breakWhile = false;
						break;
					}
				}
				if (breakWhile)
					break;
			}
			System.out.println("文件传输结束！");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	// 获得文件长度
	public long getFileSize() {
		int nFileLength = -1;
		try {
			URL url = new URL(siteInfoBean.getSSiteURL());
			HttpURLConnection httpConnection = (HttpURLConnection) url
					.openConnection();
			httpConnection.setRequestProperty("User-Agent", "NetFox");
			int responseCode = httpConnection.getResponseCode();
			if (responseCode >= 400) {
				processErrorCode(responseCode);
				return -2; // -2 为Web服务器响应错误
			}
			String sHeader;
			for (int i = 1;; i++) {
				sHeader = httpConnection.getHeaderFieldKey(i);
				if (sHeader != null) {
					if (sHeader.equals("Content-Length")) {
						nFileLength = Integer.parseInt(httpConnection
								.getHeaderField(sHeader));
						break;
					}
				} else
					break;
			}
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
		AddInform.log(nFileLength);
		return nFileLength;
	}
	// 保存传输信息（文件指针位置）
	private void writeInform() {
		try {
			output = new DataOutputStream(new FileOutputStream(tmpFile));
			output.writeInt(startPos.length);
			for (int i = 0; i < startPos.length; i++) {
				output.writeLong(fileSplitterFetch[i].startPos);
				output.writeLong(fileSplitterFetch[i].endPos);
			}
			output.close();
		} catch (Exception e) {
			System.out.println("保存传输信息失败");
		}
	}
	// 读取保存的下载信息（文件指针位置）
	private void readInform() {
		try {
			DataInputStream input = new DataInputStream(new FileInputStream(
					tmpFile));
			int nCount = input.readInt();
			startPos = new long[nCount];
			endPos = new long[nCount];
			for (int i = 0; i < startPos.length; i++) {
				startPos[i] = input.readLong();
				endPos[i] = input.readLong();
			}
			input.close();
			// 判断每块的文件开始位置是否大于结束位置
			for (int i = 0; i < startPos.length; i++) {
				if (startPos[i] > endPos[i]) {
					startPos[i] = endPos[i];
				}
			}
		} catch (Exception e) {
			System.out.println("读取保存的下载信息失败");
		}
	}
	private void processErrorCode(int nErrorCode) {
		System.err.println("Error Code : " + nErrorCode);
	}
	// 停止文件传输
	public void doStop() {
		bStop = true;
		for (int i = 0; i < startPos.length; i++)
			fileSplitterFetch[i].splitterStop();
	}
}
class FileInfo { // 定义获取和设置相关文件信息类
	private String sSiteURL; // 定义URL变量
	private String sFilePath; // 定义存文件路径变量
	private String sFileName; // 定义文件名变量
	private int nSplitter; // 定义传输文件计数值
	public FileInfo() {
		this("", "", "", 5); // 设置传输文件计数值
	}
	public FileInfo(String sURL, String sPath, String sName, int nSpiltter) {
		sSiteURL = sURL;
		sFilePath = sPath;
		sFileName = sName;
		this.nSplitter = nSpiltter;
	}
	public String getSSiteURL() {
		return sSiteURL;
	}
	public void setSSiteURL(String value) {
		sSiteURL = value;
	}
	public String getSFilePath() {
		return sFilePath;
	}
	public void setSFilePath(String value) {
		sFilePath = value;
	}
	public String getSFileName() {
		return sFileName;
	}
	public void setSFileName(String value) {
		sFileName = value;
	}
	public int getNSplitter() {
		return nSplitter;
	}
	public void setNSplitter(int nCount) {
		nSplitter = nCount;
	}
}
class FilePart extends Thread {
	String sURL; // 定义文件传输时使用的变量
	long startPos; // 分段文件传输开始位置
	long endPos; // 分段文件传输结束位置
	int nThreadID; // 子线程ID
	boolean bDownOver = false; // 完成文件传输
	boolean bStop = false; // 停止文件传输
	SaveFile fileAccess = null;
	public FilePart(String sURL, String sName, long nStart, long nEnd, int id)
			throws IOException {
		this.sURL = sURL;
		this.startPos = nStart;
		this.endPos = nEnd;
		nThreadID = id;
		fileAccess = new SaveFile(sName, startPos);
	}
	public void run() {
		while (startPos < endPos && !bStop) {
			try {
				URL url = new URL(sURL);
				HttpURLConnection httpConnection = (HttpURLConnection) url
						.openConnection();
				httpConnection.setRequestProperty("User-Agent", "NetFox");
				String sProperty = "bytes=" + startPos + "-";
				httpConnection.setRequestProperty("RANGE", sProperty);
				AddInform.log(sProperty);
				InputStream input = httpConnection.getInputStream();
				byte[] b = new byte[1024];
				int nRead;
				while ((nRead = input.read(b, 0, 1024)) > 0
						&& startPos < endPos && !bStop) {
					startPos += fileAccess.write(b, 0, nRead);
				}
				AddInform.log("Thread " + nThreadID + " is over!");
				bDownOver = true;
			} catch (Exception e) {
				System.out.println(getName() + " 线程运行异常");
			}
		}
		bDownOver = true;
	}
	public void logResponseHead(HttpURLConnection con) {
		for (int i = 1;; i++) {
			String header = con.getHeaderFieldKey(i);
			if (header != null)
				AddInform.log(header + " : " + con.getHeaderField(header));
			else
				break;
		}
	}
	public void splitterStop() {
		bStop = true;
	}
}
class SaveFile implements Serializable { // 定义访问文件类
	RandomAccessFile oSavedFile;
	long nPos;
	public SaveFile() throws IOException {
		this("", 0);
	}
	public SaveFile(String sName, long nPos) throws IOException {
		oSavedFile = new RandomAccessFile(sName, "rw");
		this.nPos = nPos;
		oSavedFile.seek(nPos);
	}
	public synchronized int write(byte[] b, int nStart, int nLen) {
		int n = -1;
		try {
			oSavedFile.write(b, nStart, nLen);
			n = nLen;
		} catch (IOException e) {
			System.out.println("同步存储信息异常");
		}
		return n;
	}
}
 class AddInform { // 定义输出提示信息及线程sleep类
	public AddInform() {
	}
	public static void sleep(int nSecond) {
		try {
			Thread.sleep(nSecond);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void log(String sMsg) {
		System.out.println(sMsg);
	}
	public static void log(int sMsg) {
		System.out.println(sMsg);
	}
}

 

　　实例248 滚动的珠子

package Chapter17;

import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MoveBall extends Frame implements ActionListener {
	// 创建3个按扭组件，分别代表开始、停止和退出
	private Button quit = new Button("退出");
	private Button start = new Button("开始");
	private Button stop = new Button("停止");
	private DrawBall balls[] = new DrawBall[20];
	// 构造方法，对各组件进行初始化
	public MoveBall() {
		super();
		setLayout(new FlowLayout());
		add(quit);
		quit.addActionListener(this);
		add(start);
		start.addActionListener(this);
		add(stop);
		stop.addActionListener(this);
		validate();
		this.setBackground(Color.black);
		this.setSize(300, 300);
		this.setVisible(true);
		for (int i = 0; i < balls.length; i++) {
			int x = (int) (getSize().width * Math.random());
			int y = (int) (getSize().height * Math.random());
			balls[i] = new DrawBall(this, x, y);
		}
	}
	public void actionPerformed(ActionEvent e) {// 为Button添加事件处理
		if (e.getSource() == stop) {// 单击停止按扭
			for (int i = 0; i < balls.length; i++) {
				balls[i].setRun();
			}
		}
		if (e.getSource() == start) {// 单击开始按扭
			for (int i = 0; i < balls.length; i++) {
				balls[i].setRun();
				balls[i] = new DrawBall(this, balls[i].x, balls[i].y);
			}
		}
		if (e.getSource() == quit) {// 单击退出按扭
			System.exit(0);
		}
	}
	public void paint(Graphics g) {// 绘制组件
		for (int i = 0; i < balls.length; i++)
			if (balls[i] != null)
				balls[i].paintBall(g);
	}
	public static void main(String[] args) {// 程序的入口处
		MoveBall t = new MoveBall();
	}
}
class DrawBall extends Thread {// 绘画珠子
	// 利用随机数获取绘制珠子的位置
	private int a = 2 * (1 - 2 * (int) Math.round(Math.random()));
	private int b = 2 * (1 - 2 * (int) Math.round(Math.random()));
	private boolean running = false;// 控制是否绘制珠子的标志
	private MoveBall table = null;// 声明一个MoveBall对象
	protected int x, y;// 定义XY坐标点
	public DrawBall(MoveBall _table, int _x, int _y) {// 构造方法，给其成员变量赋初值
		table = _table;
		x = _x;
		y = _y;
		start();
	}
	public void start() {
		running = true;
		super.start();// 启动线程
	}
	public void setRun() {
		running = false;
	}
	public void run() {// 重写Thread类的run方法
		while (running) {
			move();
			try {
				sleep(50);
			} catch (InterruptedException e) {
				System.out.println(e.getMessage());
			}
			table.repaint();
		}
	}
	public void paintBall(Graphics g) {// 自定义绘制珠子的方法
		g.setColor(Color.red);
		g.fillOval(x, y, 20, 20);
	}
	private void move() {// 珠子在滚动
		x += a;
		y += b;
		if ((x > table.getSize().width) || (x < 0)) {
			a *= (-1);
		}
		if ((y > table.getSize().height) || (y < 0)) {
			b *= (-1);
		}
	}
}

 

　　实例249 余额查询

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

public class QueryBalance extends JPanel {
	private JTextField acctext;// 声明一个录入帐号的输入框
	private JTextField pass;// 声明一个录入帐号密码的输入框
	private JButton button1;// 声明一个查询按扭
	private JButton button2;// 声明一个取消按扭
	private JLabel balanceL;// 声明一个录入帐号的输入框
	private volatile Thread lookupThread;// 创建一个线程
	public QueryBalance() {// 构造方法
		mainFrame();
		searchEvents();
	}
	private void mainFrame() {
		// 创建组件
		JLabel Lacct = new JLabel("账户编号:");
		JLabel Lpass = new JLabel("密码:");
		acctext = new JTextField(12);
		pass = new JTextField(4);
		JPanel mainPanel = new JPanel();// 创建一个面板对象
		mainPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
		// 将组件添加到面板中
		mainPanel.add(Lacct);
		mainPanel.add(acctext);
		mainPanel.add(Lpass);
		mainPanel.add(pass);
		// 创建Button按扭
		button1 = new JButton("查询");
		button2 = new JButton("取消查询");
		button2.setEnabled(false);
		// 创建装载Button组件的面板
		JPanel buttonPanel = new JPanel();
		buttonPanel.setLayout(new GridLayout(1, -1, 5, 5));
		// 将Button组件添加到buttonPanel面板中
		buttonPanel.add(button1);
		buttonPanel.add(button2);
		JPanel addPanel = new JPanel();
		addPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
		addPanel.add(buttonPanel);// 将buttonPanel面板添加到addPanel面板中
		JLabel balancePrefixL = new JLabel("账户余额:");
		balanceL = new JLabel("查询未知");
		// 将用于显示查询结果的组件放到searchPanel面板中
		JPanel searchPanel = new JPanel();
		searchPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
		searchPanel.add(balancePrefixL);
		searchPanel.add(balanceL);
		JPanel showPanel = new JPanel();
		showPanel.setLayout(new GridLayout(-1, 1, 5, 5));
		showPanel.add(mainPanel);
		showPanel.add(addPanel);
		showPanel.add(searchPanel);
		setLayout(new BorderLayout());
		add(showPanel, BorderLayout.NORTH);
	}
	private void searchEvents() {// 为查询按扭和取消按扭
		button1.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				searchING();
			}
		});
		button2.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				cancelSearch();
			}
		});
	}
	private void searchING() {// 正在查询的过程中
		ensureEventThread();
		button1.setEnabled(false);
		button2.setEnabled(true);
		balanceL.setText("正在查询 请稍候 ...");
		// 获取录入的账号和密码
		String acct = acctext.getText();
		String pin = pass.getText();
		lookupMessage(acct, pin);
	}
	private void lookupMessage(String acct, String pin) {// 设置查询信息
		final String acctNum = acct;
		final String pinNum = pin;
		Runnable lookupRun = new Runnable() {
			public void run() {
				String bal = searchAndCheck(acctNum, pinNum);
				setSafe(bal);
			}
		};
		lookupThread = new Thread(lookupRun, "lookupThread");
		lookupThread.start();
	}
	private String searchAndCheck(String acct, String pin) {// 检查账号和密码是否输入正确
		try {
			Thread.sleep(5000);
			if (!acct.equals("220302113325") && pin.equals("198713")) {
				return "您输入的账号错误！";
			} else if (acct.equals("220302113325") && !pin.equals("198713")) {
				return "您输入的密码错误！";
			}
			return "1,234.56";
		} catch (InterruptedException x) {
			return "取消查询";
		}
	}
	private void setSafe(String newBal) {// 进行安全设置
		final String newBalance = newBal;
		Runnable r = new Runnable() {
			public void run() {
				try {
					setValue(newBalance);
				} catch (Exception x) {
					x.printStackTrace();
				}
			}
		};
		SwingUtilities.invokeLater(r);
	}
	private void setValue(String newBalance) {// 获取查询结果
		ensureEventThread();
		balanceL.setText(newBalance);
		button2.setEnabled(false);// 正在查询的过程中，取消查询按扭是不用的
		button1.setEnabled(true);
	}
	private void cancelSearch() {// 取消查询
		ensureEventThread();
		button2.setEnabled(false); // prevent additional requests
		if (lookupThread != null) {
			lookupThread.interrupt();
		}
	}
	private void ensureEventThread() {
		if (SwingUtilities.isEventDispatchThread()) {
			return;
		}
		throw new RuntimeException("只有线程可以调用此方法");
	}
	public static void main(String[] args) {
		QueryBalance qb = new QueryBalance();
		JFrame f = new JFrame("Balance Lookup");
		f.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		f.setContentPane(qb);
		f.setSize(400, 150);
		f.setVisible(true);
	}
}

 

　　实例250 滚动的文字

package Chapter17.status;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;

import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class CryptoService extends JComponent {
	private BufferedImage image;// 声明一个BufferedImage类对象
	private Dimension imageOfSize;// 声明一个Dimension类对象
	private volatile int currOffset;// 声明一个用于表示偏移量的变量
	private Thread thread;// 声明一个线程
	private volatile boolean flag;
	public CryptoService(String text) {
		currOffset = 0;
		buildImage(text);
		setMinimumSize(imageOfSize);
		setPreferredSize(imageOfSize);
		setMaximumSize(imageOfSize);
		setSize(imageOfSize);
		flag = true;
		Runnable r = new Runnable() {
			public void run() {
				try {
					ScrollING();
				} catch (Exception x) {
					x.printStackTrace();
				}
			}
		};
		thread = new Thread(r, "ScrollText");
		thread.start();
	}
	private void buildImage(String text) {
		RenderingHints renderHints = new RenderingHints(
				RenderingHints.KEY_ANTIALIASING,
				RenderingHints.VALUE_ANTIALIAS_ON);// 根据抗锯齿提示键和抗锯齿提示值来创建一个RenderingHints类对象
		renderHints.put(RenderingHints.KEY_RENDERING,
				RenderingHints.VALUE_RENDER_QUALITY);// 将指定的呈现提示键映射到此RenderingHints对象中的指定呈现指示值。
		BufferedImage scratchImage = new BufferedImage(1, 1,
				BufferedImage.TYPE_INT_RGB);// 构造一个类型为预定义的图像
		Graphics2D scratchG2 = scratchImage.createGraphics();// 创建一个Graphics2D类对象
		scratchG2.setRenderingHints(renderHints);// 设置呈现算法
		Font font = new Font("Serif", Font.BOLD | Font.ITALIC, 24);// 创建一个Font字体对象
		FontRenderContext frc = scratchG2.getFontRenderContext();// 创建一个FontRenderContext对象
		TextLayout tl = new TextLayout(text, font, frc);// 创建一个TextLayout对象
		Rectangle2D textBounds = tl.getBounds();// 创建一个Rectangle2D对象
		int textWidth = (int) Math.ceil(textBounds.getWidth());// 设置文字的显示宽度
		int textHeight = (int) Math.ceil(textBounds.getHeight());// 设置文字的显示长度
		int horizontalPad = 10;// 设置水平间距为10象素
		int verticalPad = 6;// 设置垂直间距为6象素
		imageOfSize = new Dimension(// 创建Dimension对象
				textWidth + horizontalPad, textHeight + verticalPad);
		image = new BufferedImage(
				// 创建BufferedImage对象
				imageOfSize.width, imageOfSize.height,
				BufferedImage.TYPE_INT_RGB);
		Graphics2D g2 = image.createGraphics();
		g2.setRenderingHints(renderHints);
		int baselineOffset = (verticalPad / 2) - ((int) textBounds.getY());// 基线的偏移量
		g2.setColor(Color.black);// 设为黑色背影
		g2.fillRect(0, 0, imageOfSize.width, imageOfSize.height);
		g2.setColor(Color.WHITE);// 白色字体
		tl.draw(g2, 0, baselineOffset);
		scratchG2.dispose();
		scratchImage.flush();
		g2.dispose();
	}
	public void paint(Graphics g) {
		// 将当前的剪贴区设置为由给定坐标指定的矩形。
		g.setClip(0, 0, imageOfSize.width, imageOfSize.height);
		int localOffset = currOffset; // 本地偏移量是不断的变化的
		g.drawImage(image, -localOffset, 0, this);
		g.drawImage(image, imageOfSize.width - localOffset, 0, this);
		// 绘画出边框
		g.setColor(Color.red);
		g.drawRect(0, 0, imageOfSize.width - 1, imageOfSize.height - 1);
	}
	private void ScrollING() {// 执行滚动操作
		while (flag) {
			try {
				Thread.sleep(100); 
				currOffset = (currOffset + 1) % imageOfSize.width;
				repaint();
			} catch (InterruptedException x) {
				Thread.currentThread().interrupt();
			}
		}
	}
	public static void main(String[] args) {
		CryptoService st = new CryptoService("教师节快乐");
		JPanel p = new JPanel(new FlowLayout());
		p.add(st);
		JFrame f = new JFrame("滚动的文字");
		f.setContentPane(p);
		f.setSize(400, 100);
		f.setVisible(true);
	}
}

 

　　实例251 漂浮效果

package Chapter17;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;

import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

import Chapter17.status.CryptoService;

public class FloatingEffect extends Object {
	private Component comp;// 创建一个Component对象
	// 定义显示位置的X、Y坐标点
	private int initX;
	private int initY;
	// 定义偏移位置的X、Y坐标点
	private int offsetX;
	private int offsetY;
	// 标志是否是第一次执行
	private boolean firstTime;
	// 声明一个实现Runnable接口的匿名内部类对象
	private Runnable runable;
	// 声明一个线程对象
	private Thread thread;
	// 标识是否停止浮动
	private volatile boolean flag;
	// 构造方法，为其成员变量初始化
	public FloatingEffect(Component comp, int initX, int initY, int offsetX,
			int offsetY) {
		this.comp = comp;
		this.initX = initX;
		this.initY = initY;
		this.offsetX = offsetX;
		this.offsetY = offsetY;
		firstTime = true;
		runable = new Runnable() {
			public void run() {
				newPosition();
			}
		};
		flag = true;
		Runnable r = new Runnable() {// 实现Runnable接口的匿名内部类
			public void run() {
				try {
					floatING();
				} catch (Exception x) {
					// in case ANY exception slips through
					x.printStackTrace();
				}
			}
		};
		thread = new Thread(r);// 线程实例化
		thread.start();// 启动线程
	}
	private void floatING() {// 执行漂浮
		while (flag) {
			try {
				Thread.sleep(200);
				SwingUtilities.invokeAndWait(runable);
			} catch (InterruptedException ix) {
				// ignore
			} catch (Exception x) {
				x.printStackTrace();
			}
		}
	}
	private void newPosition() {// 更新新的坐标值
		if (!comp.isVisible()) {// 判断此组件在其父容器内是否可见
			return;
		}
		Component parent = comp.getParent();// 获得此组件的父级
		if (parent == null) {
			return;
		}
		Dimension parentSize = parent.getSize();
		if ((parentSize == null) && (parentSize.width < 1)
				&& (parentSize.height < 1)) {
			return;
		}
		int newX = 0;
		int newY = 0;
		if (firstTime) {
			firstTime = false;
			newX = initX;
			newY = initY;
		} else {
			Point loc = comp.getLocation();
			newX = loc.x + offsetX;
			newY = loc.y + offsetY;
		}
		newX = newX % parentSize.width;
		newY = newY % parentSize.height;
		if (newX < 0) {
			// 绕到另一侧
			newX += parentSize.width;
		}
		if (newY < 0) {
			newY += parentSize.height;
		}
		comp.setLocation(newX, newY);
		parent.repaint();
	}
	public static void main(String[] args) {// 执行该程序的主入中
		Component[] comp = new Component[6];// 创建一个Component组件数组
		comp[0] = new CryptoService("幸福");
		comp[1] = new CryptoService("快乐");
		comp[2] = new ImageShow("E:\\tupian\\1.jpg", 30);
		comp[3] = new ImageShow("E:\\tupian\\1.jpg", 30);
		comp[4] = new ImageShow("E:\\tupian\\2.jpg", 100);
		comp[5] = new ImageShow("E:\\tupian\\2.jpg", 100);
		JPanel p = new JPanel();
		p.setBackground(Color.white);
		p.setLayout(null);
		for (int i = 0; i < comp.length; i++) {
			p.add(comp[i]);
			int x = (int) (300 * Math.random());
			int y = (int) (200 * Math.random());
			int xOff = 2 - (int) (5 * Math.random());
			int yOff = 2 - (int) (5 * Math.random());
			new FloatingEffect(comp[i], x, y, xOff, yOff);
		}
		JFrame f = new JFrame("漂浮效果");
		f.setContentPane(p);
		f.setSize(400, 300);
		f.setVisible(true);
	}
}
class ImageShow extends JComponent {// 其类的主
	private Dimension size;// 显示图像的尺寸
	private volatile int imgLength;// 绘制图像的大小
	private Thread thread;// 声明一个线程对象
	private Image im;// 声明一个图像对象
	private static String imgUrl = "";// 表示图片所示磁盘的位置
	public ImageShow(String image, int n) {
		imgUrl = image;
		imgLength = 0;
		size = new Dimension(n, n);
		creatImage();
		setMinimumSize(size);// 设置此组件的最小尺寸
		setPreferredSize(size);// 设置此组件的首先尺寸
		setMaximumSize(size);// 设置此组件的最大尺寸
		setSize(size);// 调整组件的大小
		Runnable r = new Runnable() {
			public void run() {
				try {
					showING();
				} catch (Exception x) {
					x.printStackTrace();
				}
			}
		};
		thread = new Thread(r, "ImageShow");
		thread.start();
	}
	private void creatImage() {// 获取图片对象
		ImageIcon ic = new ImageIcon(imgUrl);
		im = ic.getImage();
	}
	public void paint(Graphics g) {// 绘制图像
		g.drawImage(im, imgLength, imgLength + 2, this);
	}
	private void showING() {// 显示图象
		while (true) {
			try {
				Thread.sleep(300); // 休眠3毫秒
				imgLength = imgLength + 1;
				if (imgLength > 30) {// 如果图象边框的长度大于30
					imgLength = 0;// 边框设为0
				}
				repaint();// 重新绘制图像
			} catch (InterruptedException x) {
				Thread.currentThread().interrupt();
			}
		}
	}
}

 

　　实例252 监视内存的使用情况

package Chapter17;

import java.awt.BorderLayout;
import java.awt.Dimension;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.SwingConstants;

//监控内存
public class Memory extends JFrame {
	private JPanel panel;
	private BorderLayout layout = new BorderLayout();
	// 创建JProgressBar对象并实例化
	private JProgressBar bar_1 = new JProgressBar();
	private JLabel label_1 = new JLabel();
	private JLabel label_2 = new JLabel();
	private void Initial() throws Exception {
		panel = (JPanel) this.getContentPane();
		panel.setLayout(layout);
		this.setSize(new Dimension(305, 215));
		this.setTitle("内存的使用情况");
		label_1.setFont(new java.awt.Font("Dialog", 0, 14));
		label_1.setHorizontalAlignment(SwingConstants.CENTER);
		label_1.setText("自定义任务管理器");
		bar_1.setOrientation(JProgressBar.VERTICAL);
		bar_1.setFont(new java.awt.Font("Dialog", 0, 14));
		bar_1.setToolTipText("");
		bar_1.setStringPainted(true);
		label_2.setFont(new java.awt.Font("Dialog", 0, 14));
		label_2.setText("");
		panel.add(bar_1, BorderLayout.CENTER);
		panel.add(label_1, BorderLayout.NORTH);
		panel.add(label_2, BorderLayout.SOUTH);
		ProgressThread pt = new ProgressThread(this.bar_1, this.label_2);
		pt.start();
		this.setVisible(true);
	}
	public static void main(String[] args) {
		try {
			new Memory().Initial();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class ProgressThread extends Thread {
	JProgressBar jpb;
	JLabel jl;
	public ProgressThread(JProgressBar jpb, JLabel jl) {
		this.jpb = jpb;
		this.jl = jl;
	}
	public void run() {
		int min = 0;
		int max = 100;
		int free = 0;
		int totle = 0;
		int status = 0;
		jpb.setMinimum(min);
		jpb.setMaximum(max);
		jpb.setValue(status);
		while (true) {
			totle = (int) (Runtime.getRuntime().totalMemory() / 1024);
			free = (int) (Runtime.getRuntime().freeMemory() / 1024);
			jl.setText("可用内存"
					+ (int) (Runtime.getRuntime().freeMemory() / 1024) + "K"
					+ " 总共分配的内存："
					+ (int) (Runtime.getRuntime().totalMemory() / 1024) + "K");
			status = (int) (free * 100 / totle);
			jpb.setValue(status);
			jpb.setString("可用内存：" + status + "%");
			try {
				this.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 

　　实例253 璀璨的星空

package Chapter17.example;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;

public class Universe extends java.applet.Applet implements Runnable {
	int Width, Height;// 定义小程序的长和宽
	Thread thread = null;// 声明一个线程对象
	boolean suspend = false;// 是否暂停
	Image im;// 声明一个图象对象
	Graphics graphics;// 声明一个Graphics对象
	double rot, dx, ddx;// 声明double型变量
	int speed, stars, type;// 声明int型变量
	double defddx, max;// 声明double型变量
	Star pol[]; // 星光
	public void init() {// 初始化Applet小程序
		rot = 0;
		dx = 0;
		ddx = 0;
		Width = 300;
		Height = 300;
		String theSpeed = "25";
		Show("speed", theSpeed);
		speed = (theSpeed == null) ? 50 : Integer.valueOf(theSpeed).intValue();
		String theStars = "250";
		Show("stars", theStars);
		stars = (theStars == null) ? 30 : Integer.valueOf(theStars).intValue();
		try {
			im = createImage(Width, Height);
			graphics = im.getGraphics();
		} catch (Exception e) {
			graphics = null;
		}
		pol = new Star[stars];
		for (int i = 0; i < stars; i++)
			pol[i] = new Star(Width, Height, 150, type);
		System.out.println(Width + "," + Height);
	}
	public void paint(Graphics g) {// 绘制组件
		if (graphics != null) {
			paintStart(graphics);
			g.drawImage(im, 0, 0, this);
		} else {
			paintStart(g);
		}
	}
	public void paintStart(Graphics g) {
		g.setColor(Color.black);
		g.fillRect(0, 0, Width, Height);
		for (int i = 0; i < stars; i++)
			pol[i].DrawSelf(g, rot);
	}
	public void start() {// 启动Applet小程序
		if (thread == null) {
			thread = new Thread(this);
			thread.start();// 启动线程
		}
	}
	public void stop() {// 停止运行Applet小程序
		if (thread != null) {
			thread.stop();
			thread = null;
		}
	}
	public void run() {// 运行线程
		while (thread != null) {
			rot += dx;
			dx += ddx;
			if (dx > max)
				ddx = -defddx;
			if (dx < -max)
				ddx = defddx;
			try {
				Thread.sleep(speed);
			} catch (InterruptedException e) {
			}
			repaint();
		}
	}
	public void update(Graphics g) {// 重新绘制组伯
		paint(g);
	}
	public void Show(String theString, String theValue) {
		if (theValue == null) {
			System.out.println(theString + " : null");
		} else {
			System.out.println(theString + " : " + theValue);
		}
	}
}
class Star {// 代表星星类
	int H, V;
	int x, y, z;
	int type;
	Star(int width, int height, int depth, int type) {// 构造函数为各变量初始化
		this.type = type;
		H = width / 2;
		V = height / 2;
		x = (int) (Math.random() * width) - H;
		y = (int) (Math.random() * height) - V;
		if ((x == 0) && (y == 0))
			x = 10;
		z = (int) (Math.random() * depth);
	}
	public void DrawSelf(Graphics g, double rot) {// 根据坐标绘制星星
		double X, Y;
		int h, v, hh, vv;
		int d;
		z -= 2;
		if (z < -63)
			z = 100;
		hh = (x * 64) / (64 + z);
		vv = (y * 64) / (64 + z);
		X = (hh * Math.cos(rot)) - (vv * Math.sin(rot));
		Y = (hh * Math.sin(rot)) + (vv * Math.cos(rot));
		h = (int) X + H;
		v = (int) Y + V;
		if ((h < 0) || (h > (2 * H)))
			z = 100;
		if ((v < 0) || (v > (2 * H)))
			z = 100;
		setColor(g);
		if (type == 0) {
			d = (100 - z) / 50;
			if (d == 0)
				d = 1;
			g.fillRect(h, v, d, d);
		} else {
			d = (100 - z) / 20;
			g.drawLine(h - d, v, h + d, v);
			g.drawLine(h, v - d, h, v + d);
			if (z < 50) {
				d /= 2;
				g.drawLine(h - d, v - d, h + d, v + d);
				g.drawLine(h + d, v - d, h - d, v + d);
			}
		}
	}
	public void setColor(Graphics g) {// 给绘制的对象设置颜色
		if (z > 50) {
			g.setColor(Color.gray);
		} else if (z > 25) {
			g.setColor(Color.lightGray);
		} else {
			g.setColor(Color.white);
		}
	}
}

 

　　实例254 银行和超市业务的模拟

package Chapter17.bank;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


public class SimulationSite extends Frame implements ActionListener {//模拟现场场景
	//定义全局成员常量
	protected static final int num_agents=10;
	protected static final int num_initial_agents=6;
	protected static final int max_customer_delay=9000;
	protected static final int max_teller_break=1000;
	protected static final int max_no_customers=2000;
	//创建Button组件
	private Button open = new Button("开门");
	private Button close = new Button("关门");
	private Button add = new Button("欢迎光临");
	private Button del = new Button("请慢走");
	private Bank bank = new Bank();
	private Finance supermarket = new Finance("");
	//添加窗口关闭事件
	private class WindowCloser extends WindowAdapter{
		public void windowClosing(WindowEvent e){
			bank.stop();
			supermarket.stop();
			System.exit(0);
		}
	}
	public SimulationSite(){//构造方法，进行组件初始化和布局
		super("SimulationSite");
		Panel buttons = new Panel();
		buttons.setLayout(new FlowLayout());
		buttons.add(open);
		open.addActionListener(this);
		buttons.add(close);
		close.addActionListener(this);
		buttons.add(add);
		add.addActionListener(this);
		buttons.add(del);
		del.addActionListener(this);
		this.addWindowListener(new WindowCloser());
		this.setLayout(new BorderLayout());
		add("West",bank);
		add("East",supermarket);
		add("South",buttons);
		validate();
		pack();
		show();
		bank.start();
		supermarket.start();
	}
	public void actionPerformed(ActionEvent e) {//为单击按扭做事件监听
		// TODO Auto-generated method stub
		if(e.getSource()==open){
			bank.openDoor();
			supermarket.openDoor();
		}else if(e.getSource()==close){
			bank.closeDoor();
			supermarket.closeDoor();
		}else if(e.getSource()==add){
			bank.addAgent();
			supermarket.addAgent();
		}else if(e.getSource()==del){
			bank.retireAgent();
			supermarket.retireAgent();
		}
	}
	public static void main(String[] args){//本程序的入口处
		SimulationSite sl = new SimulationSite();
	}
}
 class Finance extends Panel implements Runnable {
	protected Penson[] person = new Penson[SimulationSite.num_agents];
	protected Label[] labelAgent = new Label[SimulationSite.num_agents];
	protected Label labelQueue = new Label("已服务的顾客数:0");
	protected Label labelServed = new Label("Customers servers:0");
	protected Label labelWait = new Label("Customers wait:0");
	protected int numAgents = SimulationSite.num_initial_agents;
	protected int numCustomer = 0;// 顾客数
	protected long totalWait = 0L;// 等待顾客数
	private Thread thread = null;
	private boolean doorIsOpen = false;
	public Finance(String title) {
		super();
		setup(title);
	}
	public  void updateDisplay() {
	}
	public  void generateCustomer() {
	}
	public  Customer requestCustomerFor(int id) {
		return null;
	}
	public void checkoutCustomer(int handled, long waitTime) {// 更新顾客的数量，和正在等待的总人数
		numCustomer++;
		totalWait += waitTime;
	}
	public void addAgent() {// 增加人员
		if (numAgents < SimulationSite.num_agents) {
			person[numAgents] = new Penson(this, numAgents);
			person[numAgents].start();
			numAgents++;
		}
	}
	public void retireAgent() {// 减少人员
		if (numAgents > 1) {
			person[numAgents - 1].setRunING();
			numAgents--;
		}
	}
	public void start() {
		if (thread == null) {
			thread = new Thread(this);
			doorIsOpen = true;
			thread.start();// 启动当前线程
			for (int i = 0; i < numAgents; i++) {
				person[i].start();// 启动Person类中的线程
			}
		}
	}
	public void stop() {
		doorIsOpen = false;
		thread = null;
		for (int i = 0; i < numAgents; i++) {
			person[i].setRunING();
		}
	}
	public void openDoor() {// 营业
		doorIsOpen = true;
	}
	public void closeDoor() {// 打烊
		doorIsOpen = false;
	}
	public void run() {// 重写Runnable的run方法
		while (thread == Thread.currentThread()) {
			try {
				thread.sleep((int) Math.random()
						* SimulationSite.max_no_customers);
				if (doorIsOpen) {
					generateCustomer();
					updateDisplay();
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	private void setup(String title) {// 设置状态
		Panel agentPanel = new Panel();
		agentPanel.setLayout(new GridLayout(SimulationSite.num_agents + 3, 1));
		for (int i = 0; i < SimulationSite.num_agents; i++) {
			labelAgent[i] = new Label("Penson" + i + ":served 0");
			agentPanel.add(labelAgent[i]);
			person[i] = new Penson(this, i);
		}
		for (int i = numAgents; i < SimulationSite.num_agents; i++) {
			labelAgent[i].setText("Penson" + i + ":inactive");
		}
		agentPanel.add(labelQueue);
		agentPanel.add(labelServed);
		agentPanel.add(labelWait);
		setLayout(new BorderLayout());
		add("Center", agentPanel);
		add("North", new Label(title));
	}
}
class Penson extends Thread {// 创建一个Thread类的子类Penson类
	private boolean running = false;// 是否停止运行的标志
	private Finance bn = null;
	private int id = -1;// 客户id
	private int numCustomers = 0;// 顾客数量
	public Penson(Finance _bn, int _id) {
		this.bn = _bn;
		this.id = _id;
	}
	public void start() {
		running = true;
		super.start();// 启动线程
	}
	public void setRunING() {// 设置执行状态
		running = false;
	}
	public int getNum() {// 获取顾客数量
		return numCustomers;
	}
	private void releaseCustomer(Customer customer) {// 释放顾客对象
		numCustomers++;
		bn.checkoutCustomer(numCustomers, customer.getWaitTime(new Date()));
	}
	public void run() {// 重写Thread的run方法
		while (running) {
			try {
				sleep((int) (Math.random() * SimulationSite.max_teller_break) + 1000);// 随面休眠
				Customer customer = bn.requestCustomerFor(id);
				if (customer != null) {
					sleep(customer.getDelayTime());
					releaseCustomer(customer);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
class Bank extends Finance implements Runnable {
	private ObjectQueue queue = null;
	public Bank() {
		super("中国北京银行");// 调用父类的带参构造方法
		queue = new ObjectQueue();// 创建ObjectQueue对象
	}
	public void updateDisplay() {// 更新显示
		labelServed.setText("已服务的顾客数:" + numCustomer);// 设置标签的显示内容
		if (numCustomer != 0) {
			labelWait.setText("平均等待:" + (totalWait / numCustomer));
			for (int i = 0; i < numAgents; i++) {
				labelAgent[i].setText("顾客:" + i + ": 已服务" + person[i].getNum());
			}
			for (int i = numAgents; i < SimulationSite.num_agents; i++) {
				labelAgent[i].setText("顾客:" + i + ": 未服务");
				labelQueue.setText("正在等待的顾客数:" + queue.getSize());
			}
		}
	}
	public void generateCustomer() {// 增加新的顾客，表示又有新的顾客光临
		queue.insert(new Customer());
	}
	public Customer requestCustomerFor(int id) {// 表示有顾客发出想进行服务的需求
		return queue.requestCustomer();
	}
}
//class SimulationSite extends Frame implements ActionListener {// 模拟现场场景
//	// 定义全局成员常量
//	protected static final int num_agents = 10;
//	protected static final int num_initial_agents = 6;
//	protected static final int max_customer_delay = 9000;
//	protected static final int max_teller_break = 1000;
//	protected static final int max_no_customers = 2000;
//	// 创建Button组件
//	private Button open = new Button("开门");
//	private Button close = new Button("关门");
//	private Button add = new Button("欢迎光临");
//	private Button del = new Button("请慢走");
//	private Bank bank = new Bank();
//	private Hypermarket supermarket = new Hypermarket();
//	// 添加窗口关闭事件
//	private class WindowCloser extends WindowAdapter {
//		public void windowClosing(WindowEvent e) {
//			bank.stop();
//			supermarket.stop();
//			System.exit(0);
//		}
//	}
//	public SimulationSite() {// 构造方法，进行组件初始化和布局
//		super("SimulationSite");
//		Panel buttons = new Panel();
//		buttons.setLayout(new FlowLayout());
//		buttons.add(open);
//		open.addActionListener(this);
//		buttons.add(close);
//		close.addActionListener(this);
//		buttons.add(add);
//		add.addActionListener(this);
//		buttons.add(del);
//		del.addActionListener(this);
//		this.addWindowListener(new WindowCloser());
//		this.setLayout(new BorderLayout());
//		add("West", bank);
//		add("East", supermarket);
//		add("South", buttons);
//		validate();
//		pack();
//		show();
//		bank.start();
//		supermarket.start();
//	}
//	public void actionPerformed(ActionEvent e) {// 为单击按扭做事件监听
//		// TODO Auto-generated method stub
//		if (e.getSource() == open) {
//			bank.openDoor();
//			supermarket.openDoor();
//		} else if (e.getSource() == close) {
//			bank.closeDoor();
//			supermarket.closeDoor();
//		} else if (e.getSource() == add) {
//			bank.addAgent();
//			supermarket.addAgent();
//		} else if (e.getSource() == del) {
//			bank.retireAgent();
//			supermarket.retireAgent();
//		}
//	}
//	public static void main(String[] args) {// 本程序的入口处
//		SimulationSite sl = new SimulationSite();
//	}
//}
class ObjectQueue {// 线程队列
	private List customers = new ArrayList();
	private synchronized Object performAction(String cmd, Object obj) {// 获取对象
		if (cmd.equals("insert")) {// 增加方法的操作流程
			if (customers.isEmpty())
				customers.add(obj);
			notify();
			return null;
		} else if (cmd.equals("size")) {// 获取容量
			return new Integer(customers.size());
		} else if (cmd.equals("retrieve")) {
			while (customers.size() == 0) {
				try {
					wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			Customer c = (Customer) customers.get(0);
			customers.remove(0);
			return c;
		}
		return null;
	}
	public void insert(Customer c) {// 增加操作
		performAction("insert", c);
	}
	public int getSize() {// 获取容量
		return (((Integer) performAction("size", null)).intValue());
	}
	public Customer requestCustomer() {// 请求服务
		return (Customer) performAction("retrieve", null);
	}
}
class Customer {// 顾客类
	private Date date;// 声明一个日期类的对象
	public Customer() {// 构造方法，为date对象初始化
		date = new Date();
	}
	public int getDelayTime() {// 获取超时的时间
		return (int) (Math.random() * SimulationSite.max_customer_delay);
	}
	public long getWaitTime(Date now) {// 获取等待的时间
		return now.getTime() - date.getTime();
	}
}