Java基本线程机制（四）

八、后台线程

后台线程，指在程序运行的时候再后台提供一种通用服务的线程，这种线程并不是程序不可或缺的部分。因此，当程序中所有的非后台线程都结束时，程序也就终止了，同时会杀死进程中的所有后台进程。

public class SimpleDeamons implements Runnable {

@Override
public void run() {
try {
while(true){
TimeUnit.MILLISECONDS.sleep(100);
System.out.println(Thread.currentThread() + " " + this);
}
} catch (InterruptedException e) {
System.out.print("sleep interrupt");
}
}

public static void main(String[] args)throws Exception {
for(int i = 0; i < 10; i++){
Thread deamon = new Thread(new SimpleDeamons());
deamon.setDaemon(true);
deamon.start();
}
System.out.print("All deamon started");
TimeUnit.MILLISECONDS.sleep(175);
}

}

必须在Thread.start()之前设置setDaemon(true);否则无效。
可以设计一个专门产生后台线程的线程工厂

public class DaemonThreadFactory implements ThreadFactory {

@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}

}

可以将这个线程工厂的对象传给Executors中生产ExecutorService的三个方法。则这个线程池中的所有线程都是后台线程
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DaemonFromFactory implements Runnable {

@Override
public void run() {
try {
while(true){
TimeUnit.MILLISECONDS.sleep(100);
System.out.println(Thread.currentThread() + " " + this);
}
} catch (InterruptedException e) {
System.out.print("sleep interrupt");
}
}

public static void main(String[] args)throws Exception {
ExecutorService exe = Executors.newCachedThreadPool(new DaemonThreadFactory());
for(int i = 0; i < 10; i++){
exe.execute(new DaemonFromFactory());
}
System.out.print("All deamon started");
TimeUnit.MILLISECONDS.sleep(500);
}

}

ThreadFactory可以自定义创建一些具有默认属性的线程。可以通过isDaemon（）方法确定一个线程是否是一个后台线程。
所有由后台线程生成的子线程都默认是后台线程。

以下的finally字句将不会执行，即后台线程不一定会被执行完毕。

import java.util.concurrent.TimeUnit;

public class ADaemon implements Runnable {

@Override
public void run() {
try {
System.out.println("ADaemon start");
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("this statement will not done.");
}
}

public static void main(String[] args) {
Thread t = new Thread(new ADaemon());
t.setDaemon(true);
t.start();
}

}


九、创建对象的时候启动线程
public class SelfManage implements Runnable {
private int countDown = 5;
private Thread t = new Thread(this);
public SelfManage(){
t.start();
}
@Override
public void run() {
while(countDown-- >= 0){
System.out.println(this);
}
}
public String toString(){
return Thread.currentThread().getName() + "(" + countDown + ")";
}
public static void main(String[] args) {
for(int i = 0; i < 5; i++){
new SelfManage();
}
}

}


十、加入一个线程
可以在一个线程中加入另一个线程，调用Thread.join()方法，则此时该线程会被挂起，知道被加入的线程执行完毕才会被唤醒。也可以在掉用join（）方法时带一个超市参数，如果被加入的线程在这段时间内未执行完，则此方法也会返回，让后执行该线程。

class Sleeper extends Thread{
private int duration;
public Sleeper(String name, int sleepTime){
super(name);
this.duration = sleepTime;
start();
}
public void run(){
try {
sleep(duration);
} catch (InterruptedException e) {
System.out.println(getName() + " was interrupt." + "isInterrupted():" + isInterrupted());
return;
}
System.out.println(getName() + " is awakened");
}
}

class Joiner extends Thread{
private Sleeper sleeper;
public Joiner(String name, Sleeper sleeper){
super(name);
this.sleeper = sleeper;
start();
}
public void run(){
try {
sleeper.join();
} catch (InterruptedException e) {
System.out.println("Interrupted");
return;
}
System.out.println(getName() + "Join completed");
}
}

public class Joining {
public static void main(String[] args) {
Sleeper sleepy = new Sleeper("sleepy", 500),
grumpy = new Sleeper("grumpy", 500);
Joiner dopey = new Joiner("dopey", sleepy),
doc = new Joiner("Doc", grumpy);
grumpy.interrupt();
}

}


十一、捕获异常
如果在子线程中抛出一个异常，则在主线程中是捕获不到的。如：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExceptionThread implements Runnable {

@Override
public void run() {
throw new RuntimeException();
}
public static void main(String[] args){
ExecutorService exe = Executors.newCachedThreadPool();
try{
exe.execute(new ExceptionThread());
}catch(Exception e){
System.out.println("caught exception");
}
}

}

为解决这个问题，我们可以改变Executor产生线程的方法，将一个线程工厂传给Executor的创建线程池的方法，这个工厂会为每一个他所创建的线程添加一个异常处理器。
Thread.UncaughtExceptionHandler是Java SE5的一个新接口，他里面的方法uncaughtException()会捕获线程中抛出的异常。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

class ExceptionThread2 implements Runnable{
public void run(){
Thread t = Thread.currentThread();
System.out.println("run() by " + t);
System.out.println("en:" + t.getUncaughtExceptionHandler());
throw new RuntimeException();
}
}

class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler{

@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("catch " + e);
}

}

class HandlerThreadFactory implements ThreadFactory{

@Override
public Thread newThread(Runnable r) {
System.out.println(this + " create new thread");
Thread t = new Thread(r);
System.out.println("create " + t);
t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
System.out.println("eh:" + t.getUncaughtExceptionHandler());
return t;
}

}

public class CaptureUncaughtException {
public static void main(String[] args) {
ExecutorService exe = Executors.newCachedThreadPool(new HandlerThreadFactory());
exe.execute(new ExceptionThread2());
}

}