1:后台线程(守护线程)
后台线程一半用来提供一种通用服务,不属于程序中不可或缺的部分。所有的非后台线程结束时,进程会杀死所有的后台线程。后台进程在不执行finally方法的情况下就有可能结束run方法
public class SimpleDaemos implements Runnable {
public static void main(String[] args) throws InterruptedException {
for(int i=0;i<10;i++) {
Thread daemo = new Thread(new SimpleDaemos());
daemo.setDaemon(true);
daemo.start();
}
System.out.println("All daemo started");
TimeUnit.MILLISECONDS.sleep(175);
}
public void run() {
try {
while(true) {
TimeUnit.MILLISECONDS.sleep(100);
System.out.println(Thread.currentThread() + " " + this);
}
} catch (InterruptedException e) {
System.out.println("sleep() interrupted");
}
}
}
2:ThreadFactory定制线程属性
public class DaemonFromFactory implements Runnable{
public static void main(String[] args) throws InterruptedException {
//使用一个线程工厂作为参数,创建的线程具有线程工厂的属性
ExecutorService exe = Executors.newCachedThreadPool(new DaemoThreadFactory());
for(int i=0;i<10;i++) {
exe.execute(new DaemonFromFactory());
}
System.out.println("All daemos started");
TimeUnit.MILLISECONDS.sleep(500);
}
public void run() {
}
}
/**
* 使用线程工厂创建出来的线程全部是守护线程
* @author zhuchangxin
*
*/
class DaemoThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
}
3:join()加入一个线程
在a线程上调用b.join()。则a线程等待b执行完,然后才继续执行。如果期间调用interrupt()方法打断线程,则b线程被打断,a继续向下执行
public class Joining {
public static void main(String[] args) throws InterruptedException {
Sleeper sleepy = new Sleeper("Sleepy" , 1500);// 1
Sleeper grumpy = new Sleeper("Grumpy" , 1500);// 2
Joiner dopey = new Joiner("Dopey", sleepy);// 3
Joiner doc = new Joiner("Doc", grumpy);// 4
Thread.sleep(500);
grumpy.interrupt();
}
}
class Sleeper extends Thread {
private int duration;
public Sleeper(String name,int sleepTime) {
super(name);
this.duration = sleepTime;
start();
}
public void run() {
try {
TimeUnit.MILLISECONDS.sleep(duration);// 5
} catch (InterruptedException e) {
//调用Thread父类中的getName方法
System.out.println(getName() + " was interrupted. isInterrupted(): " + isInterrupted());
return ;
}
System.out.println(getName() + " has 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");
}
System.out.println(getName() + " join completed");
}
}
输入结果:
Grumpy was interrupted. isInterrupted(): false
Doc join completed
Sleepy has awakened
Dopey join completed
4:捕获异常
我们无法捕获从线程中逃逸的异常,一旦异常逃出run方法,它将会向控制台输出,即便使用将main主体放到try,catch中
public class SimpleDaemos implements Runnable {
public static void main(String[] args) {
try {
for(int i=0;i<10;i++) {
Thread daemo = new Thread(new SimpleDaemos());
daemo.setDaemon(true);//设成守护线程
daemo.start();
}
System.out.println("All daemo started");
TimeUnit.MILLISECONDS.sleep(175);
} catch(Exception e) {
}
}
public void run() {
try {
throw new InterruptedException();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
控制台仍会输出异常
解决方法:可以Thread.UncaughtExceptionHandler接口,该接口在线程因未捕获的异常临近死亡时调用
public class CaptureUncaughtException {
public static void main(String[] args) {
ExecutorService exe = Executors.newCachedThreadPool(new HandlerThreadFactory());
exe.execute(new ExceptionThread2());
}
}
class ExceptionThread2 implements Runnable {
@Override
public void run() {
Thread t = Thread.currentThread();
System.out.println("run() by " + t);
System.out.println("eh = " + t.getUncaughtExceptionHandler());
throw new RuntimeException();
}
}
//创建一个线程工厂,由该工厂创建的线程使用自定义异常类作为默认的异常处理方法
class HandlerThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
System.out.println("eh = " + t.getUncaughtExceptionHandler());
return t;
}
}
//自定义异常类
class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("caught " + e);
}
}