怎样在线程外部控制线程运行

一个在外部控制线程运行的一个论证实例。标准的java因为安全问题取消了stop等控制方法，我想看看能不能自己把它们安全地实现。此代码已经考虑的内容如下：

• java有堵塞的功能，所以通过一个类对象的同步锁 在线程的运行中 堵塞或解堵塞 来实现 暂停或继续的功能；

• 因为java线程不允许直接关闭线程，这个实验代码中也考虑了这一点，所以停止线程的实现方法是 在线程外部先中断线程，然后在 线程运行内部 定义 处理怎样稳妥的终止程序

• 也考虑到了 多线程中的 运行对象的 数据 共享 和 同步的问题，为了方便管理多个线程的运行 设置了一个列表管理器

• 这个实验是用 多个 抽象的控制对象 与 一个可控制运行对象 结合实现的，改变运行对象的 具体功能代码 既可以改变最终功能，但是 对于控制对象的控制方法和效果 还是一样的，只是在定义运行对象时 需要考虑如何利用 lock 来卡住 正在独立运行的 线程。

因为是刚刚开始学习java的多线程的内容，所以可能有一些地方的设置考虑不周，可能还可以做一些微调。也保留了一些想到的 可能可以 调整和修改 地方的 注释，移除他们并不会影响实验代码的运行～

/**
 * @author Hanbinbin
 */
package myTest;

import java.io.IOException;
import java.util.ArrayList;

interface ILockObject{
	/**
	 * 开始
	 */
	void start();
	/**
	 * 暂停
	 */
	void pause();
	/**
	 * 暂停多久
	 */
	void pause(int delay);
	/**
	 * 停止
	 */
	void stop();
	
	/**
	 * 测试卡
	 * @throws InterruptedException
	 */
	void lockTest() throws InterruptedException;
	
}
/**
 * 必须自己定义 存储测试卡的对象，在何处测试卡；怎样处理 卡中的 异常中断
 * @author Hanbinbin
 *
 */
interface IFunObject extends Runnable{
	/**
	 * 设置测试卡，备暂停使用
	 * @param lock
	 */
	void setLock(ILockObject lock);
	/**
	 * 创建运行线程，以自定义线程属性
	 * @param threadRunnable
	 * @return
	 */
	Thread createThread(Runnable threadRunnable);
}




/**
*抽象的控制对象
*/
class LockObj implements ILockObject{

	private Thread thread;
	private FunObject runnable;
	private boolean isRun = false;
	
	
	private int timeLong = 0;
	
	LockObj(FunObject runnable){
		
		this.runnable = runnable;
		this.runnable.setLock(this);
	}
	@Override
	public void start() {
		//synchronized(this) {	
		System.out.println("start.");
		
			//if(isRun == false)
			{				
				isRun = true;
				
				//处理启动
				if(thread == null){
					synchronized(runnable) {
						thread = runnable.createThread(runnable);							
						if(thread != null){
							thread.start();							
						}
						runnable.notifyAll();
					}
				}
				else if(thread.isInterrupted()){
					
				}//else{
					//处理解除暂停
					synchronized (this) {			
						//this.notify();
						this.notifyAll();
					}
				//}
			
			}
		//}
			
	}

	@Override
	public void pause() {
		synchronized (this) 
		{
			System.out.println("pause.");
			isRun = false;	
		}
	}
	
	@Override
	public void pause(int timeLong) {
		synchronized (this) 
		{
			System.out.println("pause."+timeLong);
			if(timeLong>0){
				this.timeLong = timeLong;
				isRun = false;
				
			}
		}
		
	}
	@Override
	public void stop() {
		synchronized (this) {
			System.out.println("stop.");
			
			isRun = false;		
		
			if(this.thread != null && this.thread.isAlive()){
				this.notify();
				this.thread.interrupt();
				this.thread = null;
			}
		}
		
	}
	
	@Override
	public  void lockTest() throws InterruptedException{
			
					
			if(isRun == false)			
			{
				System.out.println("test lock.");//+thread.getName()				
				synchronized(this) { 
					if(this.timeLong==0){
						this.wait();
					}else if(this.timeLong>0){
						this.wait(timeLong);
						
						this.timeLong = 0;
						isRun = true;					
					}
				}				
			}else{
				System.out.println("test lock."+thread.getName());//
			}
			
	}
	
}
/**
*抽象的控制对象
*/
class LockList implements ILockObject{
	
	private ArrayList<ILockObject> lockObjects = new ArrayList<ILockObject>(); 
	public void add(ILockObject lockObject) {
		lockObjects.add(lockObject);
	}

	@Override
	public void start() {
		for (int i = 0; i < lockObjects.size(); i++) {
			ILockObject object = lockObjects.get(i);
			object.start();			
		}
		
	}

	@Override
	public void pause() {
		for (int i = 0; i < lockObjects.size(); i++) {
			ILockObject object = lockObjects.get(i);
			object.pause();
		}
		
	}

	@Override
	public void pause(int delay) {
		for (int i = 0; i < lockObjects.size(); i++) {
			ILockObject object = lockObjects.get(i);
			object.pause(delay);
		}
		
	}

	@Override
	public void stop() {
		for (int i = 0; i < lockObjects.size(); i++) {
			ILockObject object = lockObjects.get(i);
			object.stop();
		}
		
	}

	@Override
	public void lockTest() throws InterruptedException {		
		
	}
	
}

/**可控制运行对象*/
class FunObject implements IFunObject {

	private ILockObject lock;
	private volatile int count = 0;
	
	//@Override
	public void setLock(ILockObject lock){
		this.lock = lock;
	}
	@Override
	public  void run() {
		while(true){
			try {	
				if(this.lock != null){
					this.lock.lockTest();
				}						
				Thread.sleep(10);
				synchronized (lock) {
					System.out.println("run."+ ++count);//thread.getName()+","+
				}									
			} catch (InterruptedException e) {
				
				System.out.println("end,count:"+ count);
				return;
			}
		}
	}
	
	//Thread thread ;
	@Override
	public synchronized Thread createThread(Runnable threadRunnable) {
		Thread thread = new Thread(threadRunnable);
		thread.setPriority(4);
		thread.setDaemon(true);
		return thread;
	}
	
}
/**主程序*/
public class TestThreadControl {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		FunObject funObject = new FunObject();
		//LockObj lockObj = new LockObj(funObject)
		LockList list = new LockList();
		for (int i = 0; i < 30; i++) {
			list.add(new LockObj(funObject));
		}
		
		try {
		        //监视输入一个字符，回车完成输入
			int input = System.in.read();
			
			while(true){
				System.out.println("input:"+input);
				switch (input) {
				case 'S':
					//lockObj.start();
					list.start();
					
					break;
				case 'W':
					//lockObj.pause(5000);
					list.pause(5000);
					
					break;
				case 'P':
					//lockObj.pause();
					list.pause();
					
					break;
				case 'T':
					//lockObj.stop();
					list.stop();
					
					break;	
				case 'E':
					//lockObj.stop();
					list.stop();
					
					return;
				default:
					break;
				}		
				//System.in.reset();
				input = System.in.read();
			}			
			
		} catch (IOException e) {
			System.out.println("IOException:"+e.getMessage());
			e.printStackTrace();
			return;
		}
		

	}

}