线程池异常统一处理

public class TestException
{

static class ExecuteRunnable implements Runnable{

CountDownLatch countDownLatch;

int i;

public ExecuteRunnable(CountDownLatch
countDownLatch, int i) {

this.countDownLatch =
countDownLatch;

this.i =
i;

}



@Override

public void run()
{

try{

String s = null;

/* if(i%1000==0){

s.trim();

}*/

System.out.println("after
trim");

}finally{

System.out.println("
invoke finally ");

countDownLatch.countDown();

}

/*ExecutorService
executor = Executors.newFixedThreadPool(1);

executor.execute(new Runnable(){

@Override

public void run() {

String s = null;

s.trim();

System.out.println("inner trim");

}

});*/

}

}

public static void main(String[]
args) {



LogExceptionThreadFactory factory = new LogExceptionThreadFactory();

ExecutorService executor = Executors.newFixedThreadPool(10,factory);

CountDownLatch countDownLatch = new CountDownLatch(10000);

try{//主线程不能捕获子线程异常

for(int i=0;i<10000;i++){

executor.execute(new ExecuteRunnable(countDownLatch,i));

}

}catch(Throwable
e){ //捕捉不到子线程异常

System.out.println("
main thread not catch sub thread exception ");

}

try {

countDownLatch.await();

System.out.println("Sub
thread has processed.");

} catch (InterruptedException
e) {

System.out.println("Failed
to wait all sub threads to complete");

}

System.out.println("isRunStatus:"+factory.isRunStatus());

System.out.println("main
thread*************");

}



public void s(TestException
t){

try{

t.f();

}catch(Exception
e){ //被该方法栈捕捉到，不往上曾调用抛出了

System.out.println("catch
exception by s");

}

}

public void f(){

Integer in = null;

try{

int a
=5;

int b
=0;

int c =a/b;

}/*catch(Exception
e){ //注释后主调线程可以捕获到异常

System.out.print("fun exception");

}*/

finally{

System.out.println("
final invoke ");

}

}

}



//统一处理线程池内部异常

class LogExceptionThreadFactory implements ThreadFactory
{

private static final ThreadFactory DEFAULT_THREAD_FACTORY =
Executors.defaultThreadFactory();

private volatile boolean runStatus =
Boolean.TRUE;



@Override

public Thread
newThread(Runnable r) {

if (r
== null) throw new NullPointerException();

Thread t = DEFAULT_THREAD_FACTORY.newThread(r);

t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler()
{

@Override

public void uncaughtException(Thread
t, Throwable e) {

System.out.println("Uncaught
Exception:");

runStatus =
Boolean.FALSE;

}

});

return t;

}



public boolean isRunStatus()
{

return runStatus;

}



public void setRunStatus(boolean runStatus)
{

this.runStatus =
runStatus;

}



}