`

JAVA范例 十三)多线程编程(2)

 
阅读更多

  13.3 线程的优先级

  实例238 排座位(线程优先级)

package Chapter17;

import java.util.*;

public class ThreadPriority {
	public static void main(String[] args) { // java程序主入口处
		List list = new ArrayList();// 创建一个List对象
		Student stu1 = new Student("张三", 5, 98, 130);// 创建一个Student对象
		list.add(stu1);// 将Student对象添加到List列表中
		Student stu2 = new Student("李国", 3, 95, 150);
		list.add(stu2);
		Student stu3 = new Student("聂亮", 4, 100, 120);
		list.add(stu3);
		Student stu4 = new Student("欧阳雪", 6, 91, 140);
		list.add(stu4);
		Student stu5 = new Student("肖肖", 7, 93, 150);
		list.add(stu5);
		System.out.println("按成绩分数的高低排坐");
		new Score().RowSeat(list);
		System.out.println("按个子的高低排坐");
		new Height().RowSeat(list);
	}

}

class Height implements Runnable { // 线程实现接口Runnable
	Thread thread; // 声明一个线程

	Height() {
	} // 默认构造方法

	Height(String name) { // 构造方法初始一个线程
		thread = new Thread(this, name);
	}

	public void run() {
		System.out.println("一年一班的学生成员:" + thread.getName()); // 获得线程的名称
	}

	public void RowSeat(List list) { // 按优先级执行线程
		Student st = (Student) list.get(0);
		Student st1 = (Student) list.get(1);
		Student st2 = (Student) list.get(2);
		Student st3 = (Student) list.get(3);
		Student st4 = (Student) list.get(4);
		Height o1 = new Height(st.name);// 创建线程对象并命名
		Height o2 = new Height(st1.name);
		Height o3 = new Height(st2.name);
		Height o4 = new Height(st3.name);
		Height o5 = new Height(st4.name);
		o1.thread.setPriority(st.height / 10 - 10); // MAX_PRIORITY优先级最大
		o2.thread.setPriority(st1.height / 10 - 10); // 较次之
		o3.thread.setPriority(st2.height / 10 - 10); // NORM_PRIORITY处于中间位置
		o4.thread.setPriority(st3.height / 10 - 10);
		o5.thread.setPriority(st4.height / 10 - 10); // MIN_PRIORITY优先级最小
		o1.thread.start(); // 启动线程
		o2.thread.start();
		o3.thread.start();
		o4.thread.start();
		o5.thread.start();
		try {
			o5.thread.join(); // 等待线程运行结束
		} catch (InterruptedException e) { // 捕获拦截异常
			System.out.println("等待线程结束出错:" + e.getMessage());
		}
	}
}

class Score extends Thread {
	Thread thread;

	public Score() {
	} // 默认构造方法

	public Score(String name) { // 带参数构造方法初始一个线程
		thread = new Thread(this, name);
	}

	public void run() {
		System.out.println("一年一班的学生成员:" + thread.getName()); // 获得线程的名称
	}

	public void RowSeat(List list) { // 按优先级执行线程
		Student st = (Student) list.get(0);
		Student st1 = (Student) list.get(1);
		Student st2 = (Student) list.get(2);
		Student st3 = (Student) list.get(3);
		Student st4 = (Student) list.get(4);
		Score e1 = new Score(st.name);// 创建线程对象并命名
		Score e2 = new Score(st1.name);
		Score e3 = new Score(st2.name);
		Score e4 = new Score(st3.name);
		Score e5 = new Score(st4.name);
		e1.thread.setPriority(st.score / 10); // MAX_PRIORITY优先级最大
		e2.thread.setPriority(st1.score / 10); // 较次之
		e3.thread.setPriority(st2.score / 10); // NORM_PRIORITY处于中间位置
		e4.thread.setPriority(st3.score / 10);
		e5.thread.setPriority(st4.score / 10); // MIN_PRIORITY优先级最小
		e1.thread.start(); // 启动线程
		e2.thread.start();
		e3.thread.start();
		e4.thread.start();
		e5.thread.start();
		try {
			e5.thread.join(); // 等待线程运行结束
		} catch (InterruptedException e) { // 捕获拦截异常
			System.out.println("等待线程结束出错:" + e.getMessage());
		}
	}
}

class Student {// 学生类
	public String name;// 姓名

	public int age;// 年龄

	public int score;// 成绩

	public int height;// 身高

	public Student(String name, int age, int score, int height) {// 构造函数为各成员变量
		this.name = name;
		this.age = age;
		this.height = height;
		this.score = score;
	}

}

 

  实例239 赛车

package Chapter17.status;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;

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

public class Nascar extends JFrame {
	private JPanel panel;
	// 声明布局格式
	private BorderLayout borderLayout1 = new BorderLayout();
	private JLabel label = new JLabel();
	// 创建JProgressBar对象并实例化
	private JProgressBar bar_1 = new JProgressBar();
	private JProgressBar bar_2 = new JProgressBar();
	private JButton button_1 = new JButton();
	// 创建Priority类对象并实例化
	private Priority thread_1 = new Priority(bar_1, 10);
	private Priority thread_2 = new Priority(bar_2, 5);
	private void Initial() throws Exception {// 创建初始化程序,为其成员变量赋初值
		panel = (JPanel) this.getContentPane();
		label.setFont(new java.awt.Font("Dialog", 0, 14));
		label.setToolTipText("");
		label.setHorizontalAlignment(SwingConstants.CENTER);
		label.setText("赛车-线程的优先级(右边的优先级>左边的优先级)");
		panel.setLayout(borderLayout1);
		this.setSize(new Dimension(333, 232));
		this.setTitle("赛车比赛");
		bar_1.setOrientation(JProgressBar.VERTICAL);// 设置进度条的垂直方式
		bar_1.setFont(new java.awt.Font("Dialog", 0, 14));// 设置进度条上显示字体的大小
		bar_1.setMaximumSize(new Dimension(84, 32764));// 设置该进度条的最大值
		bar_1.setPreferredSize(new Dimension(126, 148));// 设置此组件的首选大小
		bar_1.setString("1号参赛者");// 给进度条设置显示文字
		bar_1.setStringPainted(true);
		bar_2.setOrientation(JProgressBar.VERTICAL);
		bar_2.setFont(new java.awt.Font("Dialog", 0, 14));
		bar_2.setPreferredSize(new Dimension(126, 148));
		bar_2.setString("2号参赛者");
		bar_2.setStringPainted(true);
		button_1.setFont(new java.awt.Font("Dialog", 0, 14));
		button_1.setToolTipText("");
		button_1.setText("开始");
		setSize(500, 500);
		setVisible(true);
		button_1.addActionListener(new java.awt.event.ActionListener() {
			public void actionPerformed(ActionEvent e) {
				AddEvent(e);
			}
		});
		panel.add(label, BorderLayout.NORTH);
		panel.add(bar_1, BorderLayout.WEST);
		panel.add(bar_2, BorderLayout.EAST);
		panel.add(button_1, BorderLayout.SOUTH);
	}
	void AddEvent(ActionEvent e) {// 为按扭添加事件监听
		if (((JButton) e.getSource()).getText().equals("开始")) {
			// 当单击按钮文字是"Start",则单击后设为"stop",并且创建两个Priority的实例,但这两个线程的优先级不同,然后才可以运行线程。
			this.button_1.setText("停止");
			Priority thread_1 = new Priority(this.bar_1, Thread.MAX_PRIORITY);
			thread_1.start();
			Priority thread_2 = new Priority(this.bar_2, Thread.MIN_PRIORITY);
			thread_2.start();
		} else {
			this.button_1.setText("开始");
			this.thread_1.stopped = true;
		}
	}
	public static void main(String[] args) {// 该程序的入口处
		try {
			new Nascar().Initial();// 调用该程序的Initial方法
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class Priority extends Thread {// 设置线程优先级的类
	JProgressBar bar_3;// 声明一个进度条对象
	static boolean stopped;// 声明一个是否停止的标识
	public Priority(JProgressBar bar_3, int priority) {// 构造方法为成员变量赋初值
		this.bar_3 = bar_3;
		this.stopped = false;
		this.setPriority(priority);
	}
	public void run() {// 启动线程
		int min = 0;
		int max = 1000;
		this.bar_3.setMinimum(min);
		this.bar_3.setMaximum(max / 10);
		this.bar_3.setValue(min);
		for (int i = min; i <= max; i++) {
			if (stopped) {
				break;
			} else {
				this.bar_3.setValue((int) (i / 10));
				this.bar_3.setString(String.valueOf(i));
				try {
					Thread.sleep(2);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

 

  13.4 定时器

  实例240 定时器(Timer)

package Chapter17.status;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerThread {
	public static void main(String[] args) { // java程序主入口处
		Timer timer = new Timer(); // 创建定时器类
		TimerTask tt1 = new MyTask(1);
		timer.schedule(tt1, 200); // 0.2秒后执行任务
		TimerTask tt2 = new MyTask(2);
		timer.schedule(tt2, 500, 1000); // 0.5秒后执行任务并每个1秒执行一次
		TimerTask tt3 = new MyTask(3);
		Date date = new Date(System.currentTimeMillis() + 1000);
		timer.schedule(tt3, date); // 在指定时间1秒后执行任务
		try {
			Thread.sleep(3000); // 休眠3秒钟
		} catch (InterruptedException e) { // 捕获拦截异常
			System.out.println("出现错误:" + e.getMessage());
		}
		timer.cancel(); // 终止定时器取消定时器中的任务
		System.out.println("任务定时器已经被取消");
	}
}
class MyTask extends TimerTask { // 继承时间任务类执行任务
	private int taskID = 0; // 任务编号
	public MyTask(int id) { // 带参数的构造方法进行初始化
		this.taskID = id;
	}
	public void run() { // 实现TimerTask中的方法
		System.out.println("开始执行我的第" + this.taskID + "个任务 ,执行时间为"
				+ new Date().toLocaleString());
	}
}

 

  实例241 数字定时器

import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.InvocationTargetException;
import java.text.DecimalFormat;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;

public class DigitalTimer extends JLabel implements ActionListener {// 数字计时器
	private volatile String value;// 要在文本框中显示的内容
	private Thread thread;// 声明一个线程
	private volatile boolean isStop;// 标识是否停止计时
	Runnable r = null;//声明一个Runnable子类的对象
	public DigitalTimer() {// 构造方法为Swing组件初始化
		setBorder(BorderFactory.createLineBorder(Color.blue));
		setHorizontalAlignment(SwingConstants.RIGHT);
		this.setForeground(Color.red);
		setFont(new Font("SansSerif", Font.BOLD, 16));
		setText("00000.0"); // use to size component
		setMinimumSize(getPreferredSize());
		setPreferredSize(getPreferredSize());
		setSize(getPreferredSize());
		value = "0.0";
		setText(value);
		isStop = true;
		r = new Runnable() {// 创建一个实现Runnable接口内部类对象
			public void run() {
				try {
					startTime();
				} catch (Exception x) {
					x.printStackTrace();
				}
			}
		};
		thread = new Thread(r, "Stopwatch");// 根据Runnable对象来创建一个线程
		thread.start();// 启动线程
	}
	private void startTime() {// 开始计时
		long startTime = System.currentTimeMillis();// 线程开始运行的时间
		int n = 0;// 一个时间量
		long sleepTime = 100;// 线程正在休眠的时间
		long nextSleepTime = 100;// 接下来准备休眠的时间
		DecimalFormat format = new DecimalFormat("0.0");
		Runnable updateText = new Runnable() {
			public void run() {
				setText(value);
			}
		};
		while (isStop) {
			try {
				Thread.sleep(nextSleepTime);
				n++;
				long nowTime = System.currentTimeMillis();// 获取系统的当前时间
				long elapsedTime = nowTime - startTime;// 经过的时间=当前时间-开始时间
				nextSleepTime = sleepTime + ((n * 100) - elapsedTime);
				if (nextSleepTime < 0) {
					nextSleepTime = 0;
				}
				value = format.format(elapsedTime / 1000.0);
				System.out.println(value);
				SwingUtilities.invokeAndWait(updateText);// 使该线程在Swing组件上同步执行
			} catch (InterruptedException ix) {
				return;// 停止运行
			} catch (InvocationTargetException x) {
				x.printStackTrace();
			}
		}
	}
	public void endTime() {// 结束计时
		isStop = false;
		thread.interrupt();// 中断线程
	}
	public boolean isAlive() {
		return thread.isAlive();// 判断该线程是否是活动的
	}
	public static void main(String[] args) {
		DigitalTimer dt = new DigitalTimer();// 创建一个本类的实例化对象
		JPanel p = new JPanel(new FlowLayout());// 创建一个面板对象,其布局方式为流布局
		p.add(dt);// 将类对象添加到面板中
		JFrame frame = new JFrame("数字计时器");// 创建一个框架
		// 创建2个JButton按扭,其作用是开始计时和停止计时。并为其添加相应的事件处理
		JButton b1 = new JButton();
		b1.setText("开始");// 为接扭设置文本文字
		b1.setBounds(20, 40, 60, 20);// 设置按扭的大小
		b1.setActionCommand("start");// 设置激发此按扭的事件命令名称
		b1.addActionListener(dt);// 添加监听事件
		JButton b2 = new JButton();
		b2.setText("停止");
		b2.setBounds(80, 40, 60, 20);
		b2.setActionCommand("end");// 设置激发此按扭的事件命令名称
		b2.addActionListener(dt);// 添加监听事件
		frame.setContentPane(p);// 在该框架中添加面板
		frame.add(b1);// 在该框架中添加按扭组件
		frame.add(b2);
		frame.setSize(250, 100);// 设置框架的大小
		frame.setVisible(true);// 设置框架为可见
	}
	public void actionPerformed(ActionEvent e) {// 事件处理
		if (e.getActionCommand().equals("start")) {// 如果激发开始按扭
			if (!isAlive()) {// 判断如果当前的线程不处于可活动状态
				isStop = true;// 将状态设置为true
				thread = new Thread(r, "Stopwatch");// 重新根据Runnable对象来创建一个新的线程
				thread.start();// 启动新线程
			} else {
				startTime();
			}
		} else if (e.getActionCommand().equals("end")) {// 如果激发停止按扭
			endTime();// 则调用endTime方法,中断当前正在运行的线程
		}
	}
}

 

  13.5 线程连接池

  实例242 手术任务(线程池)

package Chapter17;

import java.util.*;

public class SurgeryThreadPool {
	private static Runnable createTask(final int taskID) { // 创建任务方法
		return new Runnable() {
			public void run() { // 创建手术任务
				System.out.println("手术开始,编号为" + taskID);
				System.out.println("正在手术中~~");
				System.out.println("手术结束,编号为" + taskID);
			}
		};
	}

	public static void main(String[] args) { // java程序主入口处
		ThreadTask threadPool = new ThreadTask(3); // 创建一个有个3任务线程的线程池
		try {// 休眠600毫秒,让线程池中的任务线程全部运行
			Thread.sleep(600);
		} catch (InterruptedException e) { // 捕获拦截异常
			System.out.println("线程休眠出错:" + e.getMessage());
		}
		for (int i = 0; i < 3; i++) { // 循环创建并执行任务
			threadPool.addTask(createTask(i));
		}
		threadPool.waitTaskColsed(); // 等待所有任务执行完毕
		threadPool.closePool(); // 关闭线程池
	}

}

class ThreadTask extends ThreadGroup { // 继承线程组实现线程池功能
	private boolean isStop = false; // 线程池是否关闭

	private LinkedList queue; // 工作任务队列

	private static int poolID = 1; // 线程池的编号

	private class SurgeryTask extends Thread { // 负责从工作队列中取出任务并执行的内部类
		private int id; // 任务编号

		public SurgeryTask(int id) { // 构造方法进行初始化
			super(ThreadTask.this, id + ""); // 将线程加入到当前线程组中
			this.id = id;
		}

		public void run() {
			while (!isInterrupted()) { // 判断线程是否被中断
				Runnable task = null;
				task = getTask(id); // 取出任务

				// 如果getTask()返回null或者线程执行getTask()时被中断,则结束此线程
				if (task == null)
					return;

				try {
					task.run(); // 运行任务
				} catch (Throwable t) {
					t.printStackTrace();
				}
			}
		}
	}

	public ThreadTask(int size) { // 构造方法传入线程池中的工作线程的数量
		super(poolID + ""); // 指定线程组名称
		setDaemon(true); // 继承线程组的方法用来设置是否守护线程池
		queue = new LinkedList(); // 创建工作任务队列
		for (int i = 0; i < size; i++) { // 循环创建任务线程
			new SurgeryTask(i).start(); // 根据线程池数据创建任务线程并启动线程,
		}
	}

	public synchronized void addTask(Runnable task) {// 添加新任务并执行任务
		if (isStop) { // 判断标识
			throw new IllegalStateException(); // 抛出不合理状态异常
		}
		if (task != null) {
			queue.add(task); // 向任务队列中加入一个任务
			notify(); // 唤醒待任务的工作任务线程
		}
	}

	private synchronized Runnable getTask(int id) { // 取出任务
		try {
			while (queue.size() == 0) { // 循环使线程等待任务
				if (isStop)
					return null;
				System.out.println("病人" + id + "正在等待手术...");
				wait(); // 如果任务队列中没有任务,就等待任务
			}
		} catch (InterruptedException e) { // 捕获拦截异常
			System.out.println("等待治疗出现错误:" + e.getMessage());
		}
		System.out.println("病人" + id + "开始执行手术...");
		return (Runnable) queue.removeFirst();// 返回第一个任务并从队列中删除
	}

	public synchronized void closePool() { // 关闭线程池
		if (!isStop) { // 判断标识
			waitTaskColsed(); // 等待任务线程执行完毕
			isStop = true; // 标识为真
			queue.clear(); // 任务队列清空
			interrupt(); // 唤醒线程池中的所有的工作线程
		}
	}

	public void waitTaskColsed() { // 等待任务线程把所有任务执行完毕
		synchronized (this) {
			isStop = true; // 标识为真
			notifyAll(); // 唤醒待任务的工作任务线程
		}
		Thread[] threads = new Thread[activeCount()];// 创建线程组中活动的线程组
		int count = enumerate(threads); // 获得线程组中当前所有活动的工作线程
		for (int i = 0; i < count; i++) { // 循环等待所有工作线程结束
			try {
				threads[i].join(); // 等待工作线程结束
			} catch (InterruptedException e) { // 捕获拦截异常
				System.out.println("手术失败:" + e.getMessage());
			}
		}
	}
}

 

  实例243 模拟人工服务台(线程连接池)

public class CallCenter extends Object {//客服中心
	private static int nextServiceID = 0;//下一个客服的ID
	private InterNIC iNIC;//声明网际网络信息中心对象
	private int ServiceID;//客服ID
	private InterNIC handoffBox;//声明网际网络信息中心对象
	private Thread thread;//声明一个线程对象
	private volatile boolean isStop;//停止服务的标志
	public CallCenter(InterNIC iNIC) {//构造函数
		this.iNIC = iNIC;
		ServiceID = getNextWorkerID();
		handoffBox = new InterNIC(1); 
		isStop = true;
		Runnable r = new Runnable() {
				public void run() {
					try {
						runWork();
					} catch ( Exception x ) {
						x.printStackTrace(); 
					}
				}
			};
		thread = new Thread(r);
		thread.start();
	}
	public static synchronized int getNextWorkerID() { //获取下个客服ID号
		int id = nextServiceID;
		nextServiceID++;
		return id;
	}
	public void process(Runnable target) throws InterruptedException {
		handoffBox.add(target);
	}
	private void runWork() {//正在工作中
		while ( isStop ) {
			try {
				System.out.println("客服" + (ServiceID+1) + 
						"号, 正在通话中,请稍候…");
				iNIC.add(this);
				Runnable r = (Runnable) handoffBox.remove();
				System.out.println("客服" + (ServiceID+1) + 
						"号, 正在与另一位新用户" + r+"建立通话连接…");
				runFailed(r); 
			} catch ( InterruptedException x ) {
				Thread.currentThread().interrupt(); 
			}
		}
	}
	private void runFailed(Runnable r) {//连接失败
		try {
			r.run();
		} catch ( Exception runex ) {
			System.err.println("连接失败,暂时无法接通…");
			runex.printStackTrace();
		} finally {
			Thread.interrupted();
		}
	}
	public void stopRequest() {//停止服务
		System.out.println("客服" + (ServiceID+1)+ 
				"号, 停止服务");
		isStop = false;
		thread.interrupt();
	}
	public boolean isAlive() {
		return thread.isAlive();//判断该线程是否处于活动状态
	}
}

 

public class InterNIC extends Object {
	private Object[] queue;// 声明一个队列
	private int capacity;// 信息容量
	private int size;// 大小
	private int head;// 信息头
	private int tail;// 信息尾
	public InterNIC(int cap) {
		capacity = (cap > 0) ? cap : 1; // 设初始容量为1
		queue = new Object[capacity];// 根据容量创建一个Object数组
		head = 0;
		tail = 0;
		size = 0;
	}
	public int getCapacity() {// 获取容量
		return capacity;
	}
	public synchronized int getSize() {// 获取信息的大小
		return size;
	}
	public synchronized boolean isEmpty() {// 判断信息是否空
		return (size == 0);
	}
	public synchronized boolean isFull() {// 判断信息是否
		return (size == capacity);
	}
	public synchronized void add(Object obj) throws InterruptedException {//添加信息
		waitWhileFull();
		queue[head] = obj;
		head = (head + 1) % capacity;
		size++;
		notifyAll();
	}
	public synchronized void addEach(Object[] list) throws InterruptedException {//添加信息尾部
		for (int i = 0; i < list.length; i++) {
			add(list[i]);
		}
	}
	public synchronized Object remove() throws InterruptedException {//信息的移出
		waitWhileEmpty();
		Object obj = queue[tail];
		queue[tail] = null;
		tail = (tail + 1) % capacity;
		size--;
		notifyAll();
		return obj;
	}
	public synchronized Object[] removeAll() throws InterruptedException {//信息全部移出
		Object[] list = new Object[size]; // use the current size
		for (int i = 0; i < list.length; i++) {
			list[i] = remove();
		}
		return list;
	}
	public synchronized Object[] removeAtLeastOne() throws InterruptedException {
		waitWhileEmpty();
		return removeAll();
	}
	public synchronized boolean waitUntilEmpty(long msTimeout)//逐渐将信息全部清除
			throws InterruptedException {
		if (msTimeout == 0L) {
			waitUntilEmpty();
			return true;
		}
		long endTime = System.currentTimeMillis() + msTimeout;
		long msRemaining = msTimeout;
		while (!isEmpty() && (msRemaining > 0L)) {
			wait(msRemaining);
			msRemaining = endTime - System.currentTimeMillis();
		}
		return isEmpty();
	}
	public synchronized void waitUntilEmpty() throws InterruptedException {
		while (!isEmpty()) {
			wait();
		}
	}
	public synchronized void waitWhileEmpty() throws InterruptedException {
		while (isEmpty()) {
			wait();
		}
	}
	public synchronized void waitUntilFull() throws InterruptedException {
		while (!isFull()) {
			wait();
		}
	}
	public synchronized void waitWhileFull() throws InterruptedException {
		while (isFull()) {
			wait();
		}
	}
}

 

 

public class TelephoneLine extends Object {
	private InterNIC iNIC;// 声明网际网络信息中心对象
	private CallCenter[] serviceList;// 创建一个客服对象数组
	public TelephoneLine(int numOfLine) {// 构造方法,其中numOfLine表示线路的个数
		numOfLine = Math.max(1, numOfLine);
		iNIC = new InterNIC(numOfLine);
		serviceList = new CallCenter[numOfLine];
		for (int i = 0; i < serviceList.length; i++) {
			serviceList[i] = new CallCenter(iNIC);
		}
	}
	public void execute(Runnable target) throws InterruptedException {// 执行任务
		CallCenter Service = (CallCenter) iNIC.remove();
		Service.process(target);
	}
	public void StopServiceOfID() {// 某个ID的客服停止服务
		try {
			Object[] idle = iNIC.removeAll();
			for (int i = 0; i < idle.length; i++) {
				((CallCenter) idle[i]).stopRequest();
			}
		} catch (InterruptedException x) {
			Thread.currentThread().interrupt();
		}
	}
	public void StopServiceAll() {// 全部客服停止服务
		StopServiceOfID();
		try {
			Thread.sleep(250);
		} catch (InterruptedException x) {
		}
		for (int i = 0; i < serviceList.length; i++) {
			if (serviceList[i].isAlive()) {
				serviceList[i].stopRequest();
			}
		}
	}
}

 

public class TelephoneOffice extends Object {
	public static Runnable makeRunnable(
				final String name, 
				final long firstDelay
			) {
		return new Runnable() {
				public void run() {
					try {
						System.out.println(name +": 请求拨号,正在连接中…");
						Thread.sleep(firstDelay);
						System.out.println(name + ": 正在通话中…");
						Thread.sleep(2000);
						System.out.println(name + ": 通语结束");
					} catch ( InterruptedException ix ) {
						System.out.println(name + ": 网络异常");
						return;
					} catch ( Exception x ) {
						x.printStackTrace();
					}
				}
				public String toString() {
					return name;
				}
			};
	}
	public static void main(String[] args) {
		try {
			TelephoneLine pool = new TelephoneLine(3);
			Runnable zs = makeRunnable("张三", 3000);
			pool.execute(zs);
			Runnable ls = makeRunnable("李四", 1000);
			pool.execute(ls);
			Runnable nql = makeRunnable("聂庆亮", 2000);
			pool.execute(nql);
			Runnable zxh = makeRunnable("张小红", 60000);
			pool.execute(zxh);
			Runnable yjp = makeRunnable("尹继平", 1000);
			pool.execute(yjp);
			pool.StopServiceOfID();
			Thread.sleep(2000);
			pool.StopServiceOfID();
			Thread.sleep(5000);
			pool.StopServiceAll();
		} catch ( InterruptedException ix ) {
			ix.printStackTrace();
		}
	}
}

 

 

  

分享到:
评论

相关推荐

    java多线程编程源码范例和详细说明(由浅入深,深度解读在资料后半部分).docx

    Java 多线程编程源码范例和详细说明 Java 多线程编程是一种能够同时执行多个任务的技术,可以提高程序的并发性和响应性,使得程序能够更好地利用 CPU 资源。本文将通过一个简单的 Java 多线程编程示例,向读者介绍...

    java 多线程交互简单范例

    在Java编程语言中,多线程是并发执行多个任务的核心机制。这个压缩包中的文件提供了几个关于Java多线程交互的实例,可以帮助我们深入理解如何在并发环境中控制线程的同步,确保数据的一致性和安全性。 首先,让我们...

    JAVA编程通用范例

    4. **多线程**:Java提供了内置的多线程支持,如Thread类和Runnable接口。通用范例可能会包含线程同步、锁机制(如synchronized关键字、ReentrantLock等)、并发工具类(如ExecutorService、CountDownLatch、...

    JAVAJAVA多线程教学演示系统论文

    总的来说,《JAVA多线程教学演示系统》这篇论文不仅是对JAVA多线程技术的理论探讨,更是一个实践与教学相结合的优秀范例,对于提升学生的多线程编程能力具有很高的参考价值。VB图书管理系统论文范文虽不在本文讨论...

    java多线程应用实现示例

    在Java编程语言中,多线程是其核心特性之一,它允许程序同时执行多个任务,提高了应用程序的效率和响应性。...学习这个示例有助于理解和掌握Java多线程编程,为实际项目开发中的并发处理打下坚实基础。

    Java范例大全 源码

    其次,《Java范例大全》还讲解了XML开发、Java图形编程、Java网络编程、多媒体开发、邮件开发、Java Web开发和Java安全等大量极其重要的企业级开发知识,使全书上升到一个新的高度;最后,以一个极具代表性的综合...

    Java范例开发大全

    《Java范例开发大全》共22章,内容涉及Java开发环境的搭建、Java基础类型与运算符、条件控制语句、异常处理、数组、字符串、输入输出流、面向对象及其四大特征、内部类与接口、Java常用类、集合、多线程编程、Java...

    [JAVA编程模式与范例].zip

    - 多线程编程:通过Thread类或Runnable接口创建线程,理解同步机制如synchronized关键字、wait/notify机制。 - 异常处理:学习如何使用try-catch-finally语句块,以及自定义异常类。 - IO流操作:掌握字节流、...

    大漠多线程范例源码

    【大漠多线程范例源码】是一个关于多线程编程的实例集合,由知名IT专家"大漠"提供,旨在帮助开发者深入理解和实践Java或其他编程语言中的多线程技术。多线程是现代软件开发中不可或缺的一部分,特别是在并发处理、高...

    JAVA多线程设计模式_中国铁道出版社_源码

    JAVA多线程设计模式_中国铁道出版社 本书浅显易懂的介绍了JAVA线程相关的设计模式,通过程序范例和UML图示来一一解说,书中代码的重要部分加了标注以使读者更加容易理解,再加上图文并茂,对于初学者还是程序设计...

    Java多线程下载器范例

    综上所述,"Java多线程下载器范例"涉及了Java多线程编程、文件I/O操作、线程同步和通信、下载策略等多个核心概念。通过理解和实践这些知识点,开发者可以构建出高效、稳定的文件下载工具。在实际项目中,这样的下载...

    java范例开发大全

    2. **多线程编程**:解释了线程的创建、同步机制(如synchronized关键字、wait()、notify()方法)以及线程池的使用。 3. **IO流与NIO**:对比分析了传统IO和NIO的区别,讲解了文件操作、网络通信等场景下的IO应用。 ...

    java 范例大全源代码

    多线程编程也是Java的一大特色。通过实现Runnable接口或继承Thread类,可以创建并运行多个线程。在并发编程中,锁、同步机制、并发容器(如ConcurrentHashMap)等工具用于保证线程安全。源代码会展示如何编写并发...

    《java范例大全》源代码

    《Java范例大全》源代码是一份非常宝贵的资源,它包含了大量的Java编程示例,旨在帮助开发者深入理解和掌握Java语言的各种特性和用法。这份源代码不仅覆盖了基础语法,还包括了面向对象编程、异常处理、集合框架、多...

    java开发范例大全

    6. **多线程**:Java支持并发编程,范例可能包含线程的创建、同步、线程池的使用等。理解如何在多线程环境下协调任务执行,是构建高性能应用程序的关键。 7. **反射机制**:Java的反射机制允许在运行时动态访问类的...

    Java范例开发大全源程序(下)

    《Java范例开发大全源程序(下)》是针对Java编程语言的一份宝贵资源,包含了从第12章到第22章的丰富实例代码,旨在帮助开发者深入理解和掌握Java的各项核心特性。这份资料涵盖了广泛的Java编程主题,包括但不限于...

    Java范例开发大全代码

    6. **多线程**:线程的创建(通过Thread类或实现Runnable接口)、线程同步(synchronized关键字、wait()和notify()方法)、线程池和并发工具类。 7. **反射**:动态获取类信息,创建对象,调用方法,以及修改私有...

    JAVA 范例开发大全 源代码

    《JAVA 范例开发大全 源代码》是一本为Java开发者提供的宝贵资源,它包含了近1000个可运行的Java类,涵盖了Java编程的各个方面。这些源代码实例旨在帮助读者深入理解Java语言的特性和用法,通过实践来提升编程技能。...

    Java通用范例开发金典源代码

    《Java通用范例开发金典源代码》是一个包含大量Java编程示例的资源集合,旨在帮助开发者深入理解和掌握Java编程语言的各种特性和应用场景。这个压缩包文件中的源代码覆盖了Java语言的基础到高级各个方面,是Java学习...

    Java编程模式与范例:基础开发技巧.rar

    7. **多线程编程**:Java内置了多线程支持,通过实现`Runnable`接口或继承`Thread`类创建线程。理解并发控制(如`synchronized`关键字、`Lock`接口)和线程同步机制(如`wait()`, `notify()`, `notifyAll()`)是Java...

Global site tag (gtag.js) - Google Analytics