线程、线程池、锁、线程通信、数据结构

一、线程

线程的实现方式有三种（重写Thread的run方法、实现Runnable接口、实现Callable接口）
前两种几乎是没有区别的，第一种的run方法是我们自己重写的，第二种原始的run方法会调用传入的Runnable对象的run方法。

@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

Callable与前两者的区别是需要借助FutureTask来调用，而且可以有返回值。

public interface Callable<V> {
    V call() throws Exception;
}

Thread
注意：直接调用Thread的run方法并不会启动新线程

Thread thread = new Thread() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("in thread");
    }
};
thread.start();
System.out.println("in main");
// in main
// in thread

Runnable

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("in thread");
    }
});
thread.start();
System.out.println("in main");
// in main
// in thread

Callable
FutureTask需要借助Thread来启动，Future可以用来监控任务的状态、获取返回值、甚至取消任务。

FutureTask<Integer> task = new FutureTask<>(() -> {
    Thread.sleep(1000);
    System.out.println("in thread");
    return 1;
});
new Thread(task).start();
System.out.println("in main");
System.out.println(task.get());
// in main
// in thread
// 1

线程的五种状态：新建状态（NEW）、就绪状态（RUNNABLE）、运行状态（RUNNING）、阻塞状态（BLOCKED）、死亡状态（DEAD）
Java中Thread的六种状态：NEW(新建)、RUNNABLE(运行)、BLOCKED(阻塞)、TIMED_WAITING(定时等待)、WAITING(等待)、TERMINATED(结束) 详情参见java.lang.Thread.State

二、线程池

ThreadPoolExecutor类是线程池中最核心的一个类。

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

corePoolSize：核心线程数量
maximumPoolSize：最大线程数量
keepAliveTime：闲置线程销毁的超时时间
unit：时间单位
workQueue：存放待执行任务的阻塞队列
threadFactory：线程工厂
handler：拒绝策略
ThreadPoolExecutor类的主要方法：

void execute(Runnable command);实现Executor接口，执行一个Runnable命令；
<T> Future<T> submit(Callable<T> task);实现ExecutorService接口，执行一个Callable任务，并得到一个Future对象，用来获取任务的返回值；
void shutdown();之前提交的任务有序退出，不再接受新的任务；
List<Runnable> shutdownNow();停止正在运行的任务，返回在等待列表中的任务；

Executers为我们提供了一些默认的连接池：

public static ExecutorService newCachedThreadPool() {
  return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                60L, TimeUnit.SECONDS,
                                new SynchronousQueue<Runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads) {
  return new ThreadPoolExecutor(nThreads, nThreads,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>());
}

注意：这两个连接池都是“无界”的，不建议在生产环境中使用；newCachedThreadPool最大线程数是Integer.MAX_VALUE，而newFixedThreadPool的等待队列的长度是Integer.MAX_VALUE，在某些情况下会导致OOM，极端情况下还会导致服务器负载飙高

三、锁

synchronized

private static synchronized void run(){
    synchronized (""){
        
    }
}

synchronized修饰对象方法时，锁对象是调用方法的对象，等同于
synchronized (this){}
synchronized修饰静态方法时，锁对象是调用方法的类对象，等同于
synchronized (this.getClass()){}
synchronized代码块，需手动指定锁对象，如上。
synchronized关键字在没有锁竞争的情况下为偏向锁，在有竞争之后膨胀为重量锁。可重入锁、非公平锁。

ReentrantLock
重入锁，与synchronized的主要区别是可以尝试获取锁、获取锁的线程可以响应中断事件、以及更丰富的锁操作。
ReentrantReadWriteLock
读写锁，分为读锁和写锁，读锁是共享锁，写锁是排他锁

死锁
死锁一般发生在线程持有锁并相互等待。在不同线程间获取多个锁时，保持相同的加锁顺序一般可解决此问题。

四、线程通信

CountDownLatch
闭锁。使用场景：主线程等待子线程全部完成。

public class App implements Runnable {
    public static void main(String[] args) throws Exception {
        CountDownLatch cdl = new CountDownLatch(3);
        new Thread(new App(cdl)).start();
        new Thread(new App(cdl)).start();
        new Thread(new App(cdl)).start();
        cdl.await();
        System.out.println(Thread.currentThread().getName());
    }

    private CountDownLatch cdl;

    public App(CountDownLatch cdl) {
        this.cdl = cdl;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
        cdl.countDown();
    }
}
// Thread-0
// Thread-1
// Thread-2
// main

CyclicBarrier
栅栏。使用场景：让一组线程等待至某个状态之后再全部同时执行。

public class App implements Runnable {
    public static void main(String[] args) throws Exception {
        CyclicBarrier cb = new CyclicBarrier(3);
        new Thread(new App(cb)).start();
        new Thread(new App(cb)).start();
        new Thread(new App(cb)).start();
    }

    private CyclicBarrier cb;

    public App(CyclicBarrier cb) {
        this.cb = cb;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(ThreadLocalRandom.current().nextInt(1000)+1000);
            System.out.println(Thread.currentThread().getName()+" "+System.currentTimeMillis());
            cb.await();
            System.out.println(Thread.currentThread().getName()+" "+System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
// Thread-0 1554779714006
// Thread-1 1554779714075
// Thread-2 1554779714322
// Thread-0 1554779714322
// Thread-1 1554779714322
// Thread-2 1554779714322

Exchanger

public class App implements Runnable {
    public static void main(String[] args) throws Exception {
        Exchanger<String> ex = new Exchanger<>();
        new Thread(new App(ex)).start();
        new Thread(new App(ex)).start();
    }

    private Exchanger<String> ex;

    public App(Exchanger<String> ex) {
        this.ex = ex;
    }

    @Override
    public void run() {
        try {
            String name = Thread.currentThread().getName();
            Object o = ex.exchange(name);
            System.out.println(name + " " + o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
// Thread-1 Thread-0
// Thread-0 Thread-1

五、数据结构

BlockingQueue
boolean add(E):插入成功返回true，队列满时抛出异常；
boolean offer(E):插入成功返回true，队列满时返回false；
boolean offer(E,long,TimeUnit):插入成功返回true，队列满且等待超时返回false；
void put(E):阻塞插入
E poll():出队，队列空时返回null
E poll(long,TimeUnit):出队，队列空且等待超时返回null
E take():阻塞出队
E peek():窥视头部元素

ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue、PriorityBlockingQueue
ArrayBlockingQueue有界阻塞队列
LinkedBlockingQueue“无界”阻塞队列，默认容量Integer.MAX_VALUE
SynchronousQueue只有一个元素的阻塞队列
PriorityBlockingQueue“无界”阻塞队列，未提供阻塞的插入方法add和put都是由offer实现，最大容量Integer.MAX_VALUE - 8，消费过慢可能会导致OOM

ConcurrentMap

ConcurrentHashMap
基于数组、链表/红黑树实现，写时对链表的头元素/红黑树的根元素加锁
如果链表长度大于8且map元素多于64，链表会转换为红黑树
ConcurrentSkipListMap
基于跳表实现，CAS实现的无锁并发
存储顺序为compare序

十分钟了解Java并发编程