java并发笔记

1.java的中断机制
java的中断机制就是为了让java的线程退出的一种机制，通过改变线程的状态,Thread提供了thread.interrupt方法使线程中断，然后线程可以抛出interruptedException使线程退出，或者在run()方法中判断线程的状态(isRuppted)方法，判断是否继续执行，从而使线程可以退出。

2.线程的休眠和恢复
使用sleep方法可以是当前线程进入睡眠，过了指定时间后会自动恢复。如果这个时候打断线程，会抛出InterruptException.

3.等待另外线程的终止
使用join()方法
Eg:
static class LocalSourceLoader implements Runnable{

    @Override
    public void run() {
        System.out.println("begin load LocalSourceLoader....");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("end load LocalSourceLoader....");
    }
}

static class NetWorkSourceLoader implements Runnable{

    @Override
    public void run() {
        System.out.println("begin load NetWorkSourceLoader....");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("end load NetWorkSourceLoader....");
    }
}

public static void main(String[] args) {

    LocalSourceLoader localSourceLoader = new LocalSourceLoader();

    NetWorkSourceLoader netWorkSourceLoader = new NetWorkSourceLoader();

    Thread thread1 = new Thread(localSourceLoader,"localSourceLoader");

    Thread thread2 = new Thread(netWorkSourceLoader,"netWorkSourceLoader");

    thread1.start();
    thread2.start();

    try {
        thread1.join();
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.printf("Main :load success %S",new Date());
}

4.守护线程
守护线程优先级比较低，其他线程没有执行时，才会执行，守护线程结束后，jvm也就结束程序。守护线程可以用来处理收尾的工作任务。
Eg:
/**
*
*/
package thread;

import java.util.ArrayDeque;
import java.util.Date;
import java.util.Deque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.hamcrest.core.Every;

/**
* @author JianJiang
*
*/
public class Test1 {

static class Event {

    /**
     * Date of the event
     */
    private Date date;

    /**
     * Message of the event
     */
    private String event;

    /**
     * Reads the Date of the event
     * 
     * @return the Date of the event
     */
    public Date getDate() {
        return date;
    }

    /**
     * Writes the Date of the event
     * 
     * @param date
     *            the date of the event
     */
    public void setDate(Date date) {
        this.date = date;
    }

    /**
     * Reads the message of the event
     * 
     * @return the message of the event
     */
    public String getEvent() {
        return event;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "Event [" + (date != null ? "date=" + date + ", " : "")
                + (event != null ? "event=" + event : "") + "]";
    }

    /**
     * Writes the message of the event
     * 
     * @param event
     *            the message of the event
     */
    public void setEvent(String event) {
        this.event = event;
    }

}

static class WriterTask extends Thread {

    private AtomicInteger atomicInteger = new AtomicInteger();

    private Deque<Event> deque;

    public WriterTask(Deque<Event> deque) {
        this.deque = deque;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
        for (int i = 0; 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);
            System.out.println("添加元素:"+event);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

static class CleanTask extends Thread {

    private Deque<Event> deque;

    public CleanTask(Deque<Event> deque) {
        this.deque = deque;
        setDaemon(true);
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {

        while (true) {
            Date date = new Date();
            clean(date);
        }

    }


    /**
     * Method that review the Events data structure and delete
     * the events older than ten seconds
     * @param 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 > 3000) {
                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());
        }
    }




}


public static void main(String[] args) {

    Deque<Event> deques = new ArrayDeque<>();

    WriterTask writerTask1 = new WriterTask(deques);

    WriterTask writerTask2 = new WriterTask(deques);

    WriterTask writerTask3 = new WriterTask(deques);

    CleanTask cleanTask = new CleanTask(deques);

    writerTask1.start();

    writerTask2.start();

    writerTask3.start();

    cleanTask.start();
}

}

5.线程中异常的处理
非运行时异常和运行时异常

/**
*
*/
package thread;

import java.lang.Thread.UncaughtExceptionHandler;

/**
* @author JianJiang
*
*/
public class Test1 {

static class Thread1 extends Thread{

    /* (non-Javadoc)
     * @see java.lang.Thread#run()
     */
    @Override
    public void run() {
        Integer.parseInt("sss");
    }
}


static class ExceptionHandler implements UncaughtExceptionHandler{

    @Override
    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());
    }
}

public static void main(String[] args) {
    Thread1 t = new Thread1();
    t.setUncaughtExceptionHandler(new ExceptionHandler());
    t.start();
}

}