第一章 Thread Management(线程管理) 中

涉及内容

• 创建和运行一个线程
• 获取和设置线程信息
• 打断一个线程
• 控制打断的线程
• 休眠和唤醒线程
• 等待线程的终止
• 创建和运行守护线程
• 处理线程中不受控制的异常
• 使用local thread变量
• 将线程加入组
• 处理线程组的不受控制的异常
• 通过工厂创建线程

1、休眠和唤醒线程

例子：使用sleep()方法写一个真实的日期

import java.util.Date;import java.util.concurrent.TimeUnit;public class FileClock implements Runnable {@Overridepublic void run() {for(int i=0; i<10; i++) {System.out.printf("%s\n", new Date());try{TimeUnit.SECONDS.sleep(1);}catch (InterruptedException e) {System.out.printf("FileClock已经被打断了");}}}public static void main(String[] args) {FileClock clock = new FileClock();Thread thread = new Thread(clock);thread.start();try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e){e.printStackTrace();}thread.interrupt();}}

总结：

• 1、每秒打印一次日期，到5秒之后被打断，但线程不会停止，因为已经捕获异常。
• 2、yield()也可以不在使用电脑CPU资源，但是电脑并不一定会执行。一般用于调试目的。

2、等待一个线程的finalization

使用join()方法来完成finalization

import java.util.Date;import java.util.concurrent.TimeUnit;public class DataSourcesLoader implements Runnable{@Overridepublic void run() {System.out.printf("开始数据加载DataSourcesLoader： %s\n", new Date() );try {TimeUnit.SECONDS.sleep(4);}catch (InterruptedException e){e.printStackTrace();}System.out.printf("数据加载已经完成DataSourcesLoader：%s\n", new Date());}}

import java.util.Date;import java.util.concurrent.TimeUnit;public class NetworkConnectionLoader implements Runnable {@Overridepublic void run() {System.out.printf("开始数据加载NetworkConnectionLoader： %s\n", new Date() );try {TimeUnit.SECONDS.sleep(6);}catch (InterruptedException e){e.printStackTrace();}System.out.printf("数据加载已经完成NetworkConnectionLoader：%s\n", new Date());}}

import java.util.Date;public class ThreadTest {public static void main(String[] args) {DataSourcesLoader dsLoader = new DataSourcesLoader();Thread thread1 = new Thread(dsLoader, "DataSourceThread");NetworkConnectionLoader ncLoader = new NetworkConnectionLoader();Thread thread2 = new Thread(ncLoader, "NetworkCOnnectionLoader");thread1.start();thread2.start();try{thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.printf("Main : 配置文件已经加载： %s\n", new Date());}}

总结：

• 1、join的意思就是加入(说白就是插队，你就是在当前线程插队，类似火车站花10块优先进入站台，他们又不用排队，哈哈)
• 2、join(long milliseconds)，例如 thread2.join(1000)，必须满足两个条件，1、thread2完成执行，2、过了1000毫秒
• 3、如果你想要main线程永不停止
• while(true) {
• thread1.join();
• thread2.join();
• }

3、创建和运行一个守护线程。

JVM退出之前会关闭守护线程，（垃圾回收机制就是守护线程）

例子：创建两个线程，一个线程写事件队列，一个清除事件队列，不过要等10秒之后清除事件。

import java.util.Date;public class Event {private Date date;private String event;public Date getDate() {return date;}public String getEvent() {return event;}public void setDate(Date date) {this.date = date;}public void setEvent(String event) {this.event = event;}}

import java.util.Date;import java.util.Deque;import java.util.concurrent.TimeUnit;public class WriterTask implements Runnable {private Deque<Event> deque;public WriterTask(Deque<Event> deque) {super();this.deque = deque;}@Overridepublic void run() {for (int i=1; i<100; i++) {Event event = new Event();event.setDate(new Date());event.setEvent(String.format("这个线程%s已经生产一个事件", Thread.currentThread().getId()));System.out.printf("增加：%s\n", event.getEvent() );deque.addFirst(event);try {TimeUnit.SECONDS.sleep(3);}catch (InterruptedException e) {e.printStackTrace();}}}}

import java.util.Date;import java.util.Deque;import java.util.concurrent.TimeUnit;public class CleanerTask extends Thread{private Deque<Event> deque;public CleanerTask(Deque<Event> deque)  {this.deque = deque;setDaemon(true);}@Overridepublic void run() {while(true) {Date date = new Date();try {clean(date);} catch (InterruptedException e) {e.printStackTrace();}}}private void clean(Date date) throws InterruptedException {//必须睡觉，不然话，没有执行机会？？？TimeUnit.SECONDS.sleep(1);long difference;boolean delete;if(deque.size() == 0) {return ;}delete=false;do{Event e = deque.getLast();difference = date.getTime() - e.getDate().getTime();if(difference > 10000) {System.out.printf("清除======：%s\n", e.getEvent() );deque.removeLast();delete=true;}} while (difference > 10000);if(delete) {System.out.printf("清除=======：队列的数量：%d\n", deque.size());}}}

import java.util.ArrayDeque;import java.util.Deque;public class ThreadTest {public static void main(String[] args) {Deque<Event> deque = new ArrayDeque<Event>();WriterTask writer = new WriterTask(deque);for(int i=0; i<3; i++){Thread thread = new Thread(writer);thread.start();}CleanerTask cleaner = new CleanerTask(deque);cleaner.start();}}

日志：

总结：

• 1、两个线程必须睡眠，不然会出现只有添加事件的线程运行或只有清除事件线程运行。
• 2、问题来？为啥都要睡眠，不是睡眠就把控制器交出吗？请求指教，可能是CPU调度算法不一样。

4、处理线程中不受控制的异常

Java分为两类异常

检查异常：这些异常可以进行捕捉，例如IOException、ClassNotFoundException

非检查异常：这些异常不是具体的，不可以被捕捉，例如NumberFormat Exception

幸运的是，Java提供处理非检查异常处理机制

例子：学习这种机制

import java.lang.Thread.UncaughtExceptionHandler;public class ExceptionHandler implements UncaughtExceptionHandler {@Overridepublic void uncaughtException(Thread t, Throwable e) {System.out.printf("一个异常已经被捕获\n");System.out.printf("线程ID: %s\n", t.getId());System.out.printf("异常类: %s:  %s\n", e.getClass().getName(), e.getMessage());System.out.printf("堆栈信息：\n");e.printStackTrace(System.out);System.out.printf("线程的状态： %s\n", t.getState());}}

public class Task implements Runnable{@Overridepublic void run() {int numero = Integer.parseInt("TTTT");}public static void main(String[] args) {Task task = new Task();Thread thread = new Thread(task);thread.setUncaughtExceptionHandler(new ExceptionHandler());thread.start();}}

日志：

一个异常已经被捕获线程ID: 10异常类: java.lang.NumberFormatException:  For input string: "TTTT"堆栈信息：java.lang.NumberFormatException: For input string: "TTTT"at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)at java.lang.Integer.parseInt(Integer.java:580)at java.lang.Integer.parseInt(Integer.java:615)at com.jack.Task.run(Task.java:7)at java.lang.Thread.run(Thread.java:748)线程的状态： RUNNABLE

总结：

• 1、定义非检查异常，然后设置到线程中
• 2、如果没有检查到则会直接退出程序
• 3、static方法 Thread.setDefaultUncaughtExceptionHandler(new ExceptionHandler())