java7高并发2

睡眠和恢复线程

public class FileClock implements Runnable {
@Override
public 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(“The FileClock has been interrupted”);
}
}
}
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();
}
}当调用sleep()方法，线程会睡眠，释放cpu资源。thread.interrupt()调用时，System.out.printf(“The FileClock has been interrupted”);方法会执行。yield()方法也有睡眠功能但是只用在debug目的

等待一个线程终止

public class DataSourcesLoader implements Runnable {
@Override
public void run() {
System.out.printf(“Beginning data sources loading: %s\n”,new Date());
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf(“Data sources loading has finished: %s\n”,new Date());
}
public static void main(String[] args) {
DataSourcesLoader dsLoader = new DataSourcesLoader();
Thread thread1 = new Thread(dsLoader,“DataSourceThread”);
NetworkConnectionsLoader ncLoader = new NetworkConnectionsLoader();
Thread thread2 = new Thread(ncLoader,“NetworkConnectionLoader”);
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf(“Main: Configuration has been loaded: %s\n”,new Date());
}
}
class NetworkConnectionsLoader implements Runnable {
@Override
public void run() {
System.out.printf(“Beginning NetworkConnectionsLoader loading: %s\n”,new Date());
try {
TimeUnit.SECONDS.sleep(6);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf(“Data NetworkConnectionsLoader has finished: %s\n”,new Date());
}
}可以看到，只有两 个线程终止了，主线程才执行.

创建并运行demon线程

守护线程只有在其他线程不占cpu资源的时候自己才会执行，而且当程序中只有守护线程时程序会终止。典型例子是java垃圾回收器
public class WriterTask implements Runnable {
private Deque deque;
public WriterTask (Deque deque){
this.deque=deque;
}
@Override
public void run() {
for (int i=1; i<100; i++) {
Event event=new Event();
event.setDate(new Date());
event.setEvent(String.format(“The thread %s has generated an event”,Thread.currentThread().getId()));
deque.addFirst(event);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Deque deque=new ArrayDeque<>();
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();
}
}
class CleanerTask extends Thread {
private Deque deque;
public CleanerTask(Deque deque) {
this.deque = deque;
setDaemon(true);
}
@Override
public void run() {
while (true) {
Date date = new Date();
clean(date);
}
}
private void clean(Date date) {
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("Cleaner: %s\n",e.getEvent());
            deque.removeLast();
            delete=true;
        }
    } while (difference > 10000);
    if (delete){
        System.out.printf("Cleaner: Size of the queue: %d\n",deque.size());
    }
}

}
class Event {
private Date Date;
private String event;

public java.util.Date getDate() {
    return Date;
}

public void setDate(java.util.Date date) {
    Date = date;
}

public String getEvent() {
    return event;
}

public void setEvent(String event) {
    this.event = event;
}

}
此代码中，三个写线程睡眠的时候让出cpu资源清空县城才会执行。一旦三个写线程结束，整个程序也会终止。创建守护线程，必须在start()方法前调用setDaemon()方法。并且一旦创建不能修改守护状态。你可以使用isDaemon() 方法检查一个县城是不是守护线程

处理线程中不许要被捕获的异常

java异常有两种，Checked exceptions必须被指定在throws 后面或者try catch他们例如IOException ；Unchecked exceptions可以程序不处理例如NumberFormatException
public class Task implements Runnable {
@Override
public void run() {
int numero=Integer.parseInt(“TTT”);
}
public static void main(String[] args) {
Task task=new Task();
Thread thread=new Thread(task);
thread.setUncaughtExceptionHandler(new ExceptionHandler());
thread.start();
}
}
class ExceptionHandler implements Thread.UncaughtExceptionHandler {
public void uncaughtException(Thread t, Throwable e) {
System.out.printf(“An exception has been captured\n”);
System.out.printf(“Thread: %s\n”,t.getId());
System.out.printf(“Exception: %s: %s\n”,e.getClass().getName(),e.getMessage());
System.out.printf(“Stack Trace: \n”);
e.printStackTrace(System.out);
System.out.printf(“Thread status: %s\n”,t.getState());
}
}此程序中Unchecked exception会被捕获，不影响主线程继续执行。

使用本地线程变量ThreadLocal

public class UnsafeTask implements Runnable {
private Date startDate;
@Override
public void run() {
startDate=new Date();
System.out.printf(“Starting Thread: %s : %s\n”,Thread.currentThread().getId(),startDate);
try {
TimeUnit.SECONDS.sleep( (int)Math.rint(Math.random()*10));//睡眠随机时间
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf(“Thread Finished: %s : %s\n”,Thread.currentThread().getId(),startDate);
}
public static void main(String[] args) {
UnsafeTask task=new UnsafeTask();
for (int i=0; i<10; i++){
Thread thread=new Thread(task);
thread.start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
此程序所有县城共享一个变量，所以程序运行结果是，每个线程开始时，共享的startDate都不同但是结束时startDate都相同
public class SafeTask implements Runnable {
private static ThreadLocal startDate= new ThreadLocal() {
protected Date initialValue(){
return new Date();
}
};
@Override
public void run() {
System.out.printf(“Starting Thread: %s : %s\n”,Thread.currentThread().getId(),startDate.get());
try {
TimeUnit.SECONDS.sleep((int)Math.rint(Math.random()*10));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf(“Thread Finished: %s : %s\n”,Thread.currentThread().getId(),startDate.get());
}
public static void main(String[] args) {
SafeTask task=new SafeTask();
for (int i=0; i<10; i++){
Thread thread=new Thread(task);
thread.start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}此程序因为每个线程独自拥有变量，所以打印的结束时间会不同。ThreadLocal有get() 和set() 方法，remove()方法删除当前线程的ThreadLocal存储的值