线程的使用经验（包括 Thread/Executor/Lock-free/阻塞/并发/锁等）

本次内容列表：

1.使用线程的经验：设置名称、响应中断、使用ThreadLocal

2.Executor:ExecutorService和Future

3.阻塞队列：put和take、offer和poll、drainTo

4.线程间的协调手段：lock、condition、wait、notify、notifyAll

5.Lock-free：atomic、concurrentMap.putlfAbsent、CopyOnWriteArrayList

6.关于锁使用的经验介绍

7.并发流程控制手段：CountDownlatch、Barrier

8.定时器：ScheduledExecutorService、大规模定时器TimeWheel

9.并发三大定律：Amdahl、Gustafson、Sun-Ni

1.线程的经验：无论何种方式，启动一个线程，就要给它一个名字。这对排错诊断系统监控有帮助。否则诊断问题时，无法直观知道某个线程的用途

设置名称：以下为常用的几种命名方式：

    //命名方式一：
    Thread thread = new Thread("thread name one") {
        public void run() {
            //do xxx
        }
    };

    //命名方式二：
    Thread thread = new Thread() {
        public void run() {
            //do xxx
        }
    };
    thread.setName("thread name two");
    thread.start();

//命名方式三：
public class MyThread extends Thread{
    public MyThread() {
        super("thread name three");
    }
    public void run() {
        //do xxx
    }
}
MyThread thread = new MyThread();
thread.start();  

//命名方式四：
Thread thread = new Thread(task, "thread name four");
thread.start();

响应线程中断：thread.interrupt(); 程序应该对线程中断作出恰当的响应

     //中断响应方式一：
    Thread thread = new Thread("interrupt test") {
        public void run() {
            for(;;) {
                try {
                    doXXX();
                } catch(InterruptedException e) {
                    break;
                } catch(Exception e) {
                    //handle Exception
                }
            }
        }
    };
    thread.start();

    //中断响应方式二：    
    Thread thread = new Thread("interrupt test") {
        public void run() {
            for(;;) {
                if(Thread.interrupted()) {
                    break;
                }
            }
        }
    };
    thread.start();

    //中断响应方式三：    
    public void foo() throws InterruptedException{
        if(Thread.interrupted()) {
            throw new InterruptedException();
        }
    }

ThreadLocal（局部线程变量）：它的功能非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。使用ThreadLocal，一般都是声明在静态变量中，如果不断的创建ThreadLocal而且没有调用其remove方法，将会导致内存泄漏。如果是static的ThreadLocal，一般不需要调用remove。

 2.Executor

　　为了方便并发执行任务，使用Executor用来专门执行任务的实现，任务的提交者不需要在创建管理线程，使用更方便，也减少了开销。

 　　java.util.concurrent.Executors是Executor的工厂类，通过Executors可以创建你所需要的Executor。

　任务的提交者和执行者之间的通讯手段

    ExecutorService executor = Executors.newSingleThreadExecutor();
    Callable<Object> task = new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            Object result = "";
            return result;
        }
    };
    public void subTask() {
        Future<Object> future = executor.submit(task);
        try {
            future.get();    //等待至完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

Task Submitter

    Future<Object> future = executor.submit(task);
    //等待到任务被执行完毕返回结果
    //如果任务执行出错，这里会抛ExecutionException
    future.get();
    //等待3秒，超时后会抛TimeoutException
    future.get(3, TimeUnit.SECONDS);

Task Executor

    Callable<Object> task = new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            Object result = ...;
            return result;
        }
    };

Task Submitter 把任务提交给Executor执行，他们之间需要一种通讯手段，这种手段的具体实现，通常叫做Future。Future通常包括get（阻塞至任务完成），cancel， get(timeout)（等待一段时间）等等。Future也用于异步变同步的场景。

3.阻塞队列：阻塞队列，是一种常用的并发数据结构，常用域生产者-消费者模式。

　　有多种阻塞队列：

　　ArrayBlockingQueue（最常用）

　　LinkedBolckingQueue（不会满的）

　　SynchronousQueue（size为0）

　　PriorityBlockingQueue

阻塞中常用的方法有：

注：在使用BlockingQueue的时候，尽量不要使用从Queue继承下来的方法，否则就失去了Blocking的特性了。

例1：

        final BlockingQueue<Object> blockingQ = new ArrayBlockingQueue<Object>(10);
        Thread thread = new Thread("consumer thread") {
            public void run() {
                for(;;) {
                    try {
                        Object object = blockingQ.take();    //等到有数据才继续
                        handle(object);    //处理
                    } catch (InterruptedException e) {
                        break;
                    } catch(Exception e) {
                        e.printStackTrace();
                    }   
                }
            }
        };    

例2：

final BlockingQueue<Object> blockingQ = new ArrayBlockingQueue<Object>(10);
    Thread thread = new Thread("consumer thread two") {
        public void run() {
            for(;;) {
                try {
                    Object object = blockingQ.poll(1, TimeUnit.SECONDS);    //防止死锁
                    if(object == null) {
                        //TODO
                        continue;    //或者进行其他操作
                    }
                } catch (InterruptedException e) {
                    break;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    };