Java线程和并发

Thread线程的创建，状态，优先级等

线程创建：
https://my.oschina.net/u/566591/blog/1576410
https://cloud.tencent.com/developer/article/1038547
线程状态：https://www.jianshu.com/p/d7c87eca472a
线程优先级：https://blog.csdn.net/silent_paladin/article/details/54561496
线程取消和关闭：
https://blog.csdn.net/yiduyangyi/article/details/60781941
https://blog.csdn.net/yiduyangyi/article/details/60781941
https://blog.csdn.net/spark_guo/article/details/42918581

Thread Pool线程池

https://liuzho.github.io/2017/04/17/%E7%BA%BF%E7%A8%8B%E6%B1%A0%EF%BC%8C%E8%BF%99%E4%B8%80%E7%AF%87%E6%88%96%E8%AE%B8%E5%B0%B1%E5%A4%9F%E4%BA%86/

BlockingQueue workQueue

该线程池中的任务队列：维护着等待执行的Runnable对象

当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务

常用的workQueue类型：

SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大

LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize

ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误

DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

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

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}

线程的取消和停止

锁的分类和解析，实现原理

锁的分类：https://www.cnblogs.com/qifengshi/p/6831055.html
CAS操作： https://www.cnblogs.com/zhengbin/p/5657707.html
全面理解Java内存模型(JMM)及volatile关键字
https://blog.csdn.net/javazejian/article/details/72772461
锁原理Markword：
https://www.jianshu.com/p/e674ee68fd3f
https://blog.csdn.net/congyihao/article/details/60748514

线程安全集合类

https://www.cnblogs.com/sarafill/archive/2011/05/18/2049461.html
https://www.cnblogs.com/yjd_hycf_space/p/7760248.html
http://mahuangyihao.iteye.com/blog/181156
http://www.charlesxiao.top/2015/10/20/Java%E5%AE%B9%E5%99%A8%E7%B1%BB%E5%BA%93%E7%9A%84%E5%AD%A6%E4%B9%A0%E7%A0%94%E7%A9%B6/

线程安全List：
http://xxgblog.com/2016/04/02/traverse-list-thread-safe/
https://blog.csdn.net/yangzl2008/article/details/39456817
vector复合操作线程不安全：http://www.hollischuang.com/archives/1786

关键词拾遗

threadlocal
https://juejin.im/post/5965ef1ff265da6c40737292

lock和lockInterruptly
lock方法会忽略中断请求，继续获取锁直到成功；而lockInterruptibly则直接抛出中断异常来立即响应中断，由上层调用者处理中断
https://blog.csdn.net/wojiushiwo945you/article/details/42387091
thread.join = object.wait() = condition.await()
均会释放锁。
均需要一个锁互斥变量控制。join默认thread对象锁，object对象锁，condition归属的lock锁。
thead.sleep()不释放锁
最好使用循环判断条件包围wait操作。
wait/await操作均会被打断
线程间通信的几种方式
wait/notify, join, threadlocal, inheritableThreadLocal(主线程和子线程)
https://blog.csdn.net/justloveyou_/article/details/54929949
https://www.cnblogs.com/hapjin/p/5492619.html
https://blog.csdn.net/u011514810/article/details/77131296
Timer的操作
TimerTask进入Timer后是需要排队执行的。
new Timer(true)那么当附属线程结束后，这个timer也会被销毁。
readResolve方法和序列化
https://blog.csdn.net/haydenwang8287/article/details/5964130

Java多线程和并发