Java线程组与线程未捕获的异常

// 以编程的方式控制线程，在实际编程中，一般是在受控制的线程中定义一个标志变量，其他线程通过改变标志变量的值，来控制线程的暂停
// 恢复运行及自然终止，以下Test15类就是一个可以被控制的线程，状态包括 SUSP 暂停， STOP 终止，RUN 运行
// Test15类继承于ControlledThread类，因此Test15类是受控制的线程，在Test15类的run方法的while循环中，每次循环
// 结束前都会调用checkState()方法，判断接下来到底是继续运行，还是暂停或者终止运行
// 主线程通过调用Test15对象的setStat()方法来控制Test15线程，当实例变量的count值大于5时，就让Test15线程暂停，把Test15
// 对象的实例变量count设为0，然后再使Test15线程恢复运行，主线程最后终止Test15线程的运行


// ThreadGroup类表示线程组，他能够对一组线程进行集中管理，在创建一个线程对象时，可以通过构造方法指定它所属的线程组 Thread(ThreadGroup group, String name)
// 在构造线程组的实例时，也可以显示指定父亲线程组，例如：ThreadGroup(ThreadGroup group, String name)
// ThreadGroup类的activeCount()方法返回当前活着的线程，enumerate(Thread[] tarray) 方法把当前活着的线程的引用拷贝到参数tarray中
// 问题，假如在执行group.activeCount()方法时有5个活着的线程，那么activeCount的值为5，但是当执行group.enumerate(machines)方法时已经有6个活着的线程，那么enumerate()
// 方法只会向machines数组中存放5个线程的引用，还有一个线程被忽略,所以不推荐使用ThreadGroup类，这个类还有一个有用的功能是uncaughtException()方法


// 处理线程未捕获的异常：如果当前线程没有捕获异常，那么java虚拟机会寻找相关的UncaughtExceptionHandler实例，如果找到，就调用他的uncaughtException(Thread t, Throwable e)方法
// 在Thread类中提供了一个公共的静态的UncaughtExceptionHandler内部接口，他负责处理线程未捕获的异常，接口完整名是Thread.UncaughtExceptionHandler,他的唯一方法是
// uncaughtException(Thread t,Throwable e)参数t表示抛出异常的线程，参数e表示具体的异常
// Thread类中提供了两个设置异常处理类的方法
// setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
// setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
// 第一个方法是静态方法，设置线程类的默认异常处理器，第二个方法是实例方法，设置线程实例的当前异常处理器
// ThreadGroup实现了Thread.UncaughtExceptionHandler接口，当一个线程实例抛出未捕获的异常时，java首先查找线程实例的当前异常处理器，没有找到，就会找实例所属的线程组作为异常处理器，都是调用
// uncaughtException()方法，还是没有则调用当前线程类的默认异常处理器，最后，就把来自方法调用堆栈的异常信息打印到标准输出流System.err中

// ThreadLocal类:这个类用来存放线程的局部变量，每个线程都有单独的局部变量，彼此之间不会共享，ThreadLocal<T>类主要包括以下三个方法：

class ControlledThread extends Thread{
	public static final int SUSP = 1;
	
	public static final int STOP = 2;
	
	public static final int RUN = 0;
	
	private int state = RUN;
	
	public synchronized void setStat(int state){
		this.state = state;
		if(state == RUN){
			notify();
		}
	}

	public synchronized boolean checkStat() {
		while (state == SUSP) {
			try {
				System.out.println(Thread.currentThread().getName() + ":wait");
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if (state == STOP) {
			return false;
		}
		return true;
	}
}



public class Test15 extends ControlledThread{
	private int count;
	public void run(){
		// 循环判断Test15的checkStat()是否进入终止状态,返回true就一直运行下去
		while(true){
			synchronized (this) {
				count++;
				System.out.println(Thread.currentThread().getName()+":run " + count+ " times");
			}
			if(!checkStat()){
				System.out.println(Thread.currentThread().getName()+":stop");
				break;
			}
		}
	}
	
	public synchronized int getCount(){return count;}
	
	public synchronized void reset(){count=0;System.out.println(Thread.currentThread().getName()+":reset");}
	
	public static void main(String[] args) {
		Test15 test15 = new Test15();
		// 启动test15线程
		test15.start();
		// for 循环200次
		for(int i = 0;i<200;i++){
			// 由于test15线程运行了一段时间后，将CPU使用权让给主线程，主线程判断count的值是否大于5，大于5就进入暂停状态，此时test15获得了CPU使用权，state == SUSP此时进入等待状态
			// 主线程运行reset方法将count值重新设置为0，将ControlledThread.RUN设置为运行状态，主线程中的for循环次数等于200时，则设置test15线程为停止状态
			if(test15.getCount()>5){
				test15.setStat(ControlledThread.SUSP);
				yield();
				test15.reset();
				test15.setStat(ControlledThread.RUN);
			}
			yield();
		}
		test15.setStat(ControlledThread.STOP);
	}
}


// (自定义)异常处理
class MichineHandler implements Thread.UncaughtExceptionHandler{

	@Override
	public void uncaughtException(Thread t, Throwable e) {
		
	}
}

// 线程组默认实现了Thread.UncaughtExceptionHandler，所以可以设置线程组的异常处理
class MichineGroup extends ThreadGroup{

	public MichineGroup() {
		super("MichineGroup");
	}
	@Override
	public void uncaughtException(Thread t, Throwable e) {
		// TODO Auto-generated method stub
		super.uncaughtException(t, e);
	}
}