线程系列
1. 线程不安全的原因
java内存模型： 线程内存栈<---->堆 主存，之间的读取和写入导致多线程数据不一致问题
2. Java的线程安全
（1）使用synchronized
a.方法同步时，锁定object，若方法静态锁定class
b.synchronized(this)将在进入同步块前锁定对象
c.需要避免deadlock
d.锁会耗费资源，必需时在使用
e.常量池中数据不要加锁
（2）使用concurrent.atomic包中的AtomicWrapper类如AtomicInteger
（3）使用concurrent.locks包中的Lock
（4）使用线程安全类，concurrentHashMap
（5）使用volatile关键使每个线程从主存读取数据
3. 线程池
（1）核心类ThreadPoolExecutor:
参数：
ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
• corePoolSize：核心池的大小，在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
• maximumPoolSize：线程池最大线程数；
• keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止；
• unit：参数keepAliveTime的时间单位（DAYS、HOURS、MINUTES、SECONDS 等）
• workQueue：阻塞队列，用来存储等待执行的任务；
○ ArrayBlockingQueue （有界队列）
○ LinkedBlockingQueue （无界队列）
○ SynchronousQueue
• threadFactory：线程工厂，主要用来创建线程
• handler：拒绝处理任务的策略
○ AbortPolicy：丢弃任务并抛出 RejectedExecutionException 异常。（默认这种）
○ DiscardPolicy：也是丢弃任务，但是不抛出异常
○ DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
○ CallerRunsPolicy：由调用线程处理该任务
uml图：
流程：
a. 如果currentPoolSize<corePoolSize,==>new Thread()
b.如果corePoolSize=<currentPoolSize<maxiumPoolSize
b1. 如果queue满了,==>new Thread()
b2. 如果queue未满， ==> task入queue
c.如果currentPoolSize>=maxiumPoolSize==>调用RejectedExecutionHandler
d.针对keepaliveTime,如果currentPoolSize>corePoolSize，则外面未使用的thread如果闲时>keepaliveTime==>停止thread()
（2）几种默认线程池
newFixedThreadPool: 使用无界blockQueue：linkedBlockingQueue【ReentrantLock】，每次任务进来，都要等待有线程空出来，否则多余任务入queue等待
/**
* Creates a thread pool that reuses a fixed number of threads
* operating off a shared unbounded queue. At any point, at most
* {@code nThreads} threads will be active processing tasks.
* If additional tasks are submitted when all threads are active,
* they will wait in the queue until a thread is available.
* If any thread terminates due to a failure during execution
* prior to shutdown, a new one will take its place if needed to
* execute subsequent tasks. The threads in the pool will exist
* until it is explicitly {@link ExecutorService#shutdown shutdown}.
*
* @param nThreads the number of threads in the pool
* @return the newly created thread pool
* @throws IllegalArgumentException if {@code nThreads <= 0}
*/
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
newSingleThreadPool：使用无界blockQueue:linkedBlockingQueue，相当于1个corePoolSize的fixedThreadPool
/**
* Creates an Executor that uses a single worker thread operating
* off an unbounded queue. (Note however that if this single
* thread terminates due to a failure during execution prior to
* shutdown, a new one will take its place if needed to execute
* subsequent tasks.) Tasks are guaranteed to execute
* sequentially, and no more than one task will be active at any
* given time. Unlike the otherwise equivalent
* {@code newFixedThreadPool(1)} the returned executor is
* guaranteed not to be reconfigurable to use additional threads.
*
* @return the newly created single-threaded Executor
*/
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
newCachedThreadPool：重复使用之前创建的thread如果还在，用于短命thread
/**
* Creates a thread pool that creates new threads as needed, but
* will reuse previously constructed threads when they are
* available. These pools will typically improve the performance
* of programs that execute many short-lived asynchronous tasks.
* Calls to {@code execute} will reuse previously constructed
* threads if available. If no existing thread is available, a new
* thread will be created and added to the pool. Threads that have
* not been used for sixty seconds are terminated and removed from
* the cache. Thus, a pool that remains idle for long enough will
* not consume any resources. Note that pools with similar
* properties but different details (for example, timeout parameters)
* may be created using {@link ThreadPoolExecutor} constructors.
*
* @return the newly created thread pool
*/
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
newScheduledThreadPool：定时执行
/**
* Creates a thread pool that can schedule commands to run after a
* given delay, or to execute periodically.
* @param corePoolSize the number of threads to keep in the pool,
* even if they are idle
* @return a newly created scheduled thread pool
* @throws IllegalArgumentException if {@code corePoolSize < 0}
*/
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
/**
* Creates a new {@code ScheduledThreadPoolExecutor} with the
* given core pool size.
*
* @param corePoolSize the number of threads to keep in the pool, even
* if they are idle, unless {@code allowCoreThreadTimeOut} is set
* @throws IllegalArgumentException if {@code corePoolSize < 0}
*/
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}