Java并发编程
从Java角度来看，
进程是运行时的程序，是计算机分配内存的最小单位。线程是进程的一个执行单元，是cpu执行的最小单位。
进程
程序由指令和数据组成，指令的运行，数据的读写需要将指令加载至CPU，数据运行至内存。当一个程序被运行，从磁盘加载这个程序代码至内存，这时就开启了一个进程。进程可以视为程序的一个实例。
线程
一个进程可以分为多个或一个线程。一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给CPU执行。Java中，线程作为最小调度单位，进程作为资源分配的最小单位。在windows中，进程是不活动的，只作为线程的容器。
并发(concurrent)：同一时间应对多件事情的能力。（线程轮流使用CPU）
并行：同一时间动手做多件事情的能力。
如何创建线程？
- 继承Thread类，重写run()方法
- 实现Runnable接口，重写run方法，再创建Tread对象，去执行任务
1和2的区别：继承Thread类后，由于java是单继承的，所以就不能再继承其他类了，实现Runnable接口的方式，还可以再继承其他类 - 实现Callable接口，重写call方法，创建Thread对象，去执行任务（call方法可以有返回值，可以抛出异常）
- 线程池创建
线程中常用的方法：run(),start(),join(),yield(),sleep(),wait(),notify()
线程的状态：新建，就绪，运行，阻塞，死亡
多线程安全问题：多线程共享资源操作
如何解决线程安全问题？加锁，排队，一个一个来， 并发的执行
如何加锁：
synchronized关键字：同步对象（对多个对象来讲必须是同一个），用来记录有没有线程进入到同步代码块中。可以添加在代码块上，还可以添加在方法上。
synchronized(同步对象){
同步对象要求：多个线程对应的是同一个对象，用对象头中的一块区域来记录有没有进入到同步代码块中
}
synchronized修饰方法时，锁对象有两种：
1.修饰的是非静态方法，锁对象默认是this
2.修饰的是静态方法，锁对象是该类的Class对象
static synchronized void fun(){
}
Lock接口，ReentrantLock类实现了Lock锁，它拥有了与synchronized相同的并发性和内存语义，在实现线程安全的控制中比较常用的是ReentrantLock，可以显式加锁，释放锁。
ReentrantLock实现了Lock接口，所以可以成为Lock锁。
synchronized和ReentrantLock的区别：
- 实现原理不同： ReentrantLock是一种Java代码层面的控制实现，而synchronized是关键字，依靠的是底层编译后的指令实现。
- 加锁范围不同：ReentrantLock只能对某一代码块加锁，而synchronized可以对某一代码块或者方法加锁
- 加锁，释放锁方式不同： ReentrantLock需要我们手动释放锁，而synchronized是隐式自动释放锁（代码执行结束或出现异常，自动释放锁）。
线程死锁
死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
public class DeadThread extends Thread {
static Object objA = new Object();
static Object objB = new Object();
boolean flag;
public DeadThread(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (objA) {
System.out.println("if objA");
synchronized (objB) {
System.out.println("if objB");
}
}
} else {
synchronized (objB) {
System.out.println("else objB");
synchronized (objA) {
System.out.println("else objA");
}
}
}
}
}
设计时考虑清楚锁的顺序，尽量减少嵌套的加锁交互数量。
守护线程
线程分为用户线程和守护线程，守护线程为其他线程提供服务的，最大的特点是当系统其他用户线程结束后，守护线程会自动结束。jvm垃圾回收线程就是一个守护线程
daemonThread.setDaemon(true); //设置线程为守护线程，必须在线程启动前设置
线程通信
线程通信：指多个线程通过相互牵制，相互调度，即线程间的相互作用。
涉及三个方法：
.wait一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
.notify一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就会唤醒优先级最高的那个。
.notifyAll一旦执行此方法，就会唤醒所有被wait的线程。
注意：wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
两个线程交替打印1-100数字：
public class PrintNumThread extends Thread {
static int num = 1;
static Object obj = new Object();
@Override
public void run() {
while (num <= 100) {
synchronized (obj) {
obj.notifyAll();
System.out.println(Thread.currentThread().getName() + ":" + num);
num++;
try {
if (num <= 100) {
obj.wait();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
sleep()和wait()的区别：
sleep()是让线程阻塞指定时间，时间到了之后自己唤醒进入到就绪状态，不会释放同步锁。是Thread类中的方法.
wait()让线程进入等待（阻塞），不会自己唤醒，必须通过notify/notifyAll来唤醒。是Object类中的方法
共同点：都可以让线程进入阻塞状态。
生产者消费者问题
public class Counter {
int num = 0;
public synchronized void add() {
if (num == 0) {
this.notify();
num = 1;
System.out.println("生产者生产了一个资源：" + num);
} else {
try {
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
public synchronized void sub() {
if(num==0){
try {
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}else{
this.notify();
num = 0;
System.out.println("消费者消费了一个资源：" + num);
}
}
}
-------------------------------------------------------
public class Producter extends Thread{
Counter counter;
public Producter(Counter counter) {
this.counter = counter;
}
@Override
public void run(){
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
counter.add();
}
}
}
---------------------------------------------------
public class Consumer extends Thread{
Counter counter;
public Consumer(Counter counter) {
this.counter = counter;
}
@Override
public void run(){
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
counter.sub();
}
}
}
---------------------------------------------------------
public class Test {
public static void main(String[] args) {
Counter counter=new Counter();
Consumer c = new Consumer(counter);
Producter p = new Producter(counter);
c.start();
p.start();
}
}
新增创建线程方式
实现Callable接口与使用Runnable相比，Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，获取返回结果
public class Test {
public static void main(String[] args) {
SumTask sumTask = new SumTask();
FutureTask<Integer> futureTask = new FutureTask(sumTask);
Thread thread = new Thread(futureTask);
thread.start();
Integer integer = null;
try {
integer = futureTask.get();
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
System.out.println(integer);
}
}
---------------------------------------
public class SumTask implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum=0;
for(int i=0;i<=10;i++){
sum+=i;
}
return sum;
}
}
线程进阶
多线程优点：提高线程响应速度，可以多个线程各自完成自己的工作，提高硬件设备的利用率。
缺点：在多个线程同时访问共享数据时，可能出现资源争夺问题。线程中的重点就是解决线程安全问题。（接下来解决的重点问题）
并发执行：是在一个时间段内依次轮流执行（微观串行，宏观并行）
并行执行：是真正意义上的同一时间点上一起执行
多线程场景下，对共享资源的访问应该是并发的执行
平常所说的高并发，此处指的并发，就是很多用户一起访问
并发编程核心问题：不可见性、乱序性、非原子性
不可见性
一个线程对共享变量的修改，另一个线程不能立刻看到，我们称为不可见性。
由于想让程序响应处理速度更快，java内存模型设计有主内存和工作内存（线程使用的内寸），线程中不能直接对主内存中的数据进行操作，必须将主内存数据加载到工作内存（本地内存），这样在多核CPU下，就会产生不可见性。
我们的目标要做到可见性
volatile关键字（解决不可见性、乱序性）
一旦一个共享变量被volatile关键字修饰以后，
- 保证了不同线程对这个变量操作的可见性，即一个线程修改了某个变量的值，这个新值对其他线程来说立即可见；
（可见性）- 禁止进行指令重排序；
（有序性）- volatile不能保证对变量操作的原子性。
（非原子性）
volatile的底层实现原理（待更新...）
JMM（待更新...）
乱序性
指令在执行过程中，为了优化性能，有的时候会改变程序中语句的先后顺序。
这种改变可能会影响程序整个运行结果。
CPU的读等待同时指令执行是CPU乱序执行的根源。读指令的同时可以执行不影响其他指令。
非原子性
线程切换带来的非原子性问题。
原子的意思代表不可分。一个或多个操作在CPU执行的过程中不被中断的特性，我们称为原子性。原子性是拒绝多线程交叉操作的，不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程对它进行操作。
CPU能保证原子操作是CPU指令级别的，而不是高级语言的操作符。线程导致了原子性问题。
如何保证原子性（加锁、原子变量）
同一时刻只有一个线程执行，我们称为互斥。如果我们能够保证对共享变量的修改是互斥的，那么就能保证原子性了。
- 加锁是一种阻塞式方式实现
- 原子变量是一种非阻塞式方式实现
加锁
互斥的，A线程执行时加锁，此时其他线程就不能再执行了
原子变量
在java.util.concurrent包下面提供了一些类，可以在不加锁的情况下实现++操作的原子性。这些类称为原子类AtomicInteger。
原子类内部实现是volatile+CAS机制
原子类内部实现使用了不加锁的CAS机制
CAS（compare-and-swap）算法:比较并交换
CAS算法：是一种不加锁的实现（乐观锁）机制，采用自旋的思想，当一个线程进行++操作时，可先从内存中取出共享变量，记录一个预估值，然后在工作内存中修改共享变量，当将修改的变量写回主内存前，要判断预估值是否与主内存中的值一致，如果一致说明没有其他线程修改过。如果不一致，说明其他线程修改过，需要重新获取主内存共享变量，重复之前的操作。
CAS缺点：CAS使用自旋的方式，由于该锁会不断循环判断，因此不会类似synchronized线程阻塞导致线程切换。但是不断的自旋，会导致CPU的消耗过高。
原子类适合在低并发情况使用
会产生ABA问题（A->B->A）：一个线程获取内存值为A，当线程修改后要写内存时，但已经有其他线程改变了内存值，又有线程将内存值改回到与当前预估值相同的值。
如何解决ABA问题？使用有版本号的原子类
Java中的锁分类（synchronized、ReentrantLock、ReentrantReadWriteLock）
Java中有很多锁的名词，这些并不全指锁，有的指锁的特性，有的指锁的设计，有的指锁的状态。
乐观锁/悲观锁
乐观锁
乐观锁认为对于同一个数据的并发操作，是不会发生修改的。乐观锁其实就是不加锁。并发修改时，进行比较，满足条件进行更新，否则再次比较。例如原子类。
悲观锁（例如synchronized）
悲观锁认为不加锁的是肯定会出问题的，使用java中提供的各种锁实现加锁。悲观锁适合写操作比较多的情况，乐观锁适合读多写少的情况。
可重入锁
当一个线程进入到一个同步方法中，然后在此方法中要调用另一个同步方法，而且两个方法共用同一把锁，此时线程是可以进入到另一个同步方法中的。
读写锁
ReentrantReadWriteLock可以实现读锁和写锁，读写可以使用一个锁实现，都是读的时候，多个线程可以共享这把锁（可以同时进入），一旦有写的操作，那么就要一个一个操作
读读共享
读写互斥
写写互斥
加读锁是防止在另外的线程在此时写入数据，防止读取脏数据
分段锁
JDK8之后去除了真正的分段锁，现在的分段锁不是锁，而是一种实现思想。
分段锁并非一种实际的锁，而是一种思想。用于将数据分段，并在每个分段上都会单独加锁，把锁进一步细粒度化，以提高并发效率。
例如ConcurrentHashMap，没有给方法加锁，而是用hash表中第一个节点当作锁，这样就可以有多把锁，提高并发效率。
自旋锁
也不是锁，是获取锁的方式。例如：
- 原子类，需要改变内存中的变量，需要不断尝试
- synchronized加锁，其他线程不断尝试获取锁
共享锁/独占锁
共享锁
多个线程可以共享的一把锁，读写锁中的读锁，都是读操作时多个线程共用一把锁
独占锁
synchronized、ReentratLock，互斥的，读写锁中的写锁
公平锁/非公平锁
公平锁
公平锁（Fair Lock）是按照请求锁的顺序分配，拥有稳定获取锁的机会。
非公平锁
非公平锁（Nonfair Lock）是指不按照请求锁的顺序分配，不一定拥有获取锁的机会。
synchronized是一种非公平锁
ReentrantLock默认非公平锁，但是底层可以通过AQS来实现线程调度，所以可以使其变成公平锁。
偏向锁/轻量级锁/重量级锁（锁的状态）
是针对synchronized锁的状态：
无锁状态：没有任何线程进入同步代码块偏向锁状态：当前只有一个线程访问，在对象头的Mark Word中记录线程id，下次此线程访问可直接获取锁轻量级锁状态：锁状态为偏向锁，此时继续有线程访问，升级为轻量级锁，会让线程以自旋方式获取锁，线程不会阻塞重量级锁状态：锁状态为轻量级锁，线程自旋获取锁的次数到达一定数量时，锁的状态升级为重量级锁，会让自旋次数多的线程进入到阻塞状态，因为访问量大，线程都自旋获得锁，CPU消耗大
锁的状态是通过对象监视器在对象头中的字段来表明的。四种状态会随着竞争的情况逐渐升级。
这四种状态都不是Java语言中的锁，而是JVM为了提高锁的获取与释放效率而做的优化（使用synchronized时）
偏向锁
偏向锁是指一段同步代码块一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价。
轻量级锁
轻量级锁是指当锁是偏向锁的时候，此时又有一个线程访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋形式尝试获取锁，不会阻塞，提高性能。
重量级锁
重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。在高并发情况下，出现大量线程自旋获得锁，对CPU销毁较大，升级为重量级锁后，获取不到锁的线程将阻塞，等待操作系统的调度。
以上状态设计是Java为了优化synchronized锁
对象结构
synchronized锁的实现（通过底层指令控制实现）
synchronized修饰方法：底层指令会添加ACC_SYNCHRONIZED，进入方法时使用monitorenter检测，执行完毕使用monitorexit释放锁
synchronized修饰代码块：进入代码块时使用monitorenter检测，执行完毕使用monitorexit释放锁
ReentrantLock锁实现(默认非公平锁)
源码实现：
public class ReentrantLock implements Lock, java.io.Serializable {
abstract static class Sync extends AbstractQueuedSynchronizer {
...
}
static final class NonfairSync extends Sync {
final void lock() {
if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread());
//先尝试获取锁，修改锁的状态。成功则设置为独占线程
else acquire(1);
//否则走正常流程
}
}
static final class FairSync extends Sync {
final void lock() {
acquire(1);//走正常流程获取锁，如果当前锁状态为0，则改为1
//如果状态为1，把线程放入到队列
}
}
public ReentrantLock() {
sync = new NonfairSync();
//无参构造方法
//默认使用非公平锁
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
//有参构造方法
}
}
公平锁和非公平锁继承ReentrantLock内部静态类Sync。
Sync继承AbstractQueuedSynchronizer抽象同步队列。
ReentrantLock 是 Java 并发包 (java.util.concurrent.locks) 中的一个可重入互斥锁实现类，它提供了与 synchronized 关键字相似的功能，但具有更灵活的特性。
主要特点：
- 可重入性：同一个线程可以多次获取同一个锁，内部通过计数器跟踪重入次数。
- 公平性选择：
- 非公平锁（默认）：不保证线程获取锁的顺序，性能较高但可能导致线程饥饿
- 公平锁：按照线程请求锁的顺序分配锁，减少饥饿但性能较低
- 可中断：提供了可中断的获取锁方法
- 超时尝试：可以尝试在指定时间内获取锁
使用示例：
ReentrantLock lock = new ReentrantLock();
// ...
lock.lock();
try {
// 临界区代码
} finally {
lock.unlock();
}
AQS（AbstractQueuedSynchronizer）抽象同步队列
AQS：是一个底层具体的同步实现者，很多同步的类底层都用到了AQS。
AbstractQueuedSynchronizer类中有一个int类型的state变量记录锁的状态。这个类在java.util.concurrent包下面
内部类
volatile int state;//标记有没有线程在访问共享资源
protected final int getState(){
return state;
}
static final class Node{
volatile Node prev;
volatile Node next;
volatile Thread thred;
}
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
JUC常用类
ConcurrentHashMap（java.util.concurrent包中）
存储键值对，双列集合。键不可重复，值可以重复
HashMap： hashCode();equals();哈希冲突
结构：哈希表，默认长度为16，数组长度-1 & hash值
负载因子0.75扩容为原来2倍
链表 8 哈希表长度大于等于64转红黑树
红黑树线程不安全。单线程情况下可以使用
HashTable： 是线程安全的，方法加了synchronized关键字，读也加了锁。读写互斥，并发访问效率低，适合并发量低的情况下使用
线程安全的，采用CAS+synchronized保证线程安全。
put时，先用key计算hash值，再计算位置。如果是当前位置的第一个元素，采用CAS机制尝试放入。如果当前位置已经有了元素，那么使用第一个元素作为锁对象，使用synchronized加锁。这样就会降低锁的粒度，可以同时有多个方法进入到put的方法中操作，提高并发效率。
如果有多个线程对同一位置操作，那么就必须一个一个操作。
ConcurrentHashMap不支持存储为null的键和值
HashTable不支持存储为null的键和值
原因：为了消除歧义。由于ConcurrentHashMap和HashTable都是支持并发的，当通过get(K,V)获取对应value时，如果获取到的为null，无法判断当前value为null还是这个key从未做过映射。
concurrentHashMap类putval方法源码：
final V putVal(K key, V value, boolean onlyIfAbsent) {
//首先检查 key 或 value 是否为 null，如果是则直接抛出 NullPointerException（ConcurrentHashMap 不允许空键或空值）
if (key == null || value == null) throw new NullPointerException();
//通过 spread() 方法对键的哈希码进行二次散列，目的是减少哈希冲突
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {//自旋插入逻辑（无限循环直到成功）
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)//1.情况一：表未初始化
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//2.情况二：目标桶为空
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))// 通过 (n-1) & hash 计算桶位置
break; // 使用 CAS原子操作插入新节点，避免加锁
}
else if ((fh = f.hash) == MOVED)//3.情况三：正在扩容
tab = helpTransfer(tab, f);//协助扩容
else {//4.情况四：桶不为空（需加锁）
//对桶头节点加 synchronized 锁
//处理两种子情况：链表或红黑树
V oldVal = null;
synchronized (f) {// 锁定桶头节点
if (tabAt(tab, i) == f) {// 再次验证防止被修改
if (fh >= 0) {// 普通链表节点
binCount = 1;// 遍历链表查找key，找到则更新，未找到则追加
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
else if (f instanceof TreeBin) { // 红黑树节点
// 通过树节点方式插入
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)// 超过树化阈值
treeifyBin(tab, i); // 可能转为红黑树
if (oldVal != null)
return oldVal;// 如果是更新操作返回旧值
break;
}
}
}
addCount(1L, binCount);// 原子更新元素计数器
return null;
}
设计亮点：
分段锁优化：只在操作具体桶时加锁，不同桶可并行操作
CAS无锁插入：空桶插入使用CAS避免锁开销
协助扩容：遇到正在扩容的桶会协助完成迁移
锁粒度细化：只锁单个桶头节点而非整个表
CopyOnWriteArrayList
ArrayList：单列集合 底层是数组实现 可存储重复元素 有序存储
可以自动扩容 默认长度为10 扩容为原来的1.5倍
线程不安全Vector：单列集合 底层是数组实现 可存储重复元素 有序存储
可以自动扩容 默认长度为10 扩容为原来的2倍
线程安全，锁添加到方法上的，并发效率低
读取数据时也进行加锁是一种资源的浪费，读是不改变数据的。
CopyOnWriteArrayList类中所有可变操作都是通过创建底层数组的新副本来实现的。添加、修改（写）方法加锁（使用ReentrantLock加锁），get（读）方法不加锁，提高读的效率。适合读多写少情况。
CopyOnWriteArraySet
CopyOnWriteArraySet实现基于CopyOnWriteArrayList，线程安全，不能存储重复数据。
CountDownLatch
CountDownLatch允许一个线程等待其他线程各自执行完毕后再执行。底层是通过AQS（同步队列）完成。创建CountDownLatch对象时指定一个初始值是线程的数量。每当一个线程执行完毕，AQS内部的state就-1，当state值为0，所有线程执行完毕，然后在闭锁上等待的线程就可以恢复工作了。
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch=new CountDownLatch(1000);//初始化计数器为 1000，表示需要等待 1000 个事件完成
for(int i=0;i<1000;i++){
new Thread(()->{
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("1");
countDownLatch.countDown();//调用 countDown() 减少计数器
}).start();
}
countDownLatch.await();//主线程会阻塞在这里，直到计数器减到 0
System.out.println("_______________main_______________");//当所有 1000 个线程都执行完后，主线程继续执行
}
}
典型应用场景
启动服务时等待所有组件初始化完成并行计算时等待所有子任务完成测试用例中协调多个并发操作
池（容器/集合/ArrayList）
每次连接数据库都要创建一个连接对象，用完之后就销毁了，频繁创建销毁会占用一定的开销。
提出 池的概念，可以创建一定数量的连接对象放在池子中，有连接到来时，从池子中获得一个连接对象使用，用完之后不销毁，还回到池子中即可。减少创建、销毁开销。
例如：字符串常量池、数据库连接池、线程池
数据库连接池
import com.alibaba.druid.pool.DruidDataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class DruidUtil {
static DruidDataSource dataSource;
static {
dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/ssm_db?serverTimezone=Asia/Shanghai");
dataSource.setUsername("root");
dataSource.setPassword("xxxxxxxx");
dataSource.setInitialSize(10);
dataSource.setMaxActive(20);
}
public static Connection getConnection() throws SQLException {
return dataSource.getConnection();
}
public static void close(Connection connection) throws SQLException {
connection.close();
}
}
线程池
频繁的创建线程销毁线程需要开销。java从JDK5开始就有了线程池的实现，有两个类：1.ThreadPoolExecutor；2.Executors实现线程池。其中阿里巴巴开发规约中规定使用ThreadPoolExecutor中可以准确的控制创建的数量，最大等待数量，拒绝策略等。
ThreadPoolExecutor构造方法中的七个参数：
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue unit,ThreadFactory threadFactory,RejectedExecutionHandler handler)；
- corePoolSize
核心池子的数量（大小），默认先不创建线程，有任务到达再创建，之后就不销毁了- maximumPoolSize
最大池子数量，线程池中最多能创建多少线程- keepAliveTime
表示非核心线程池中线程没有任务执行时最多保持多久时间会终止- TimeUnit unit
时间单位- BlockingQueue unit
等待队列 一个阻塞队列- threadFactory
线程工厂：主要用来创建线程- RejectedExecutionHandler handler
拒绝策略：拒绝处理任务时的策略
线程池的执行
工作流程：
线程池中的队列
ArrayBlockingQueue
ArrayBlockingQueue是一个用数组实现的有界阻塞队列，创建时必须设置长度，按FIFO排序量。
LinkedBlockingQueue
LinkedBlockingQueue是基于链表结构的阻塞队列，按FIFO排序任务，容量可以选择进行设置，不设置是一个最大长度为Integer.MAX_VALUE。
线程池的拒绝策略
当请求任务不断的过来，而系统此时又处理不过来的时候，我们就需要采取对应的拒绝策略。
默认有四种类型：
-
AbortPolicy：该策略会直接抛出异常，阻止系统正常工作。
-
CallerRunsPolicy：只要线程池未关闭，该策略在调用者线程中运行当前的任务（如果任务被拒绝了，则由提交任务的线程（如main） 直接执行此任务（可以看到执行此策略时有一个任务由main线程执行）
-
DiscardOldestPolicy：该策略将丢弃最老的一个请求，也就是即将被执行的任务，并尝试再次提交当前任务。
-
DiscardPolicy：该策略丢弃无法处理的任务，不予任何处理。
execute与submit的区别
执行任务除了execute方法还可以使用submit方法。他们的主要区别就是：execute方法不需要关注返回值的场景，submit方法适用于需要关注返回值的场景。
execute：提交实现了Runnable接口的任务，没有返回值
submit：提交实现了Callable和Runnable接口的任务，可以接收返回值
关闭线程池
关闭线程池可以调用shutdownNow和shutdown两个方法来实现。
shutdown:关闭线程时，不会再接收新的任务，会等待所有任务执行完成
shutdownNow:会终止正在执行的任务，返回还未执行的任务列表
使用线程池模拟一个秒杀系统
public class Test {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 5, 200, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(15));
for (int i = 1; i <= 20; i++) {
MyTask task = new MyTask(i);
threadPoolExecutor.execute(task);
}
threadPoolExecutor.shutdown();
}
}
public class MyTask implements Runnable {
private static int id = 10;
private int userName;
public MyTask(int num) {
this.userName = num;
}
@Override
public void run() {
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (MyTask.class) {
if (id > 0) {
System.out.println("恭喜用户" + this.userName + "，秒杀成功！还剩" + --id + "件商品！");
} else {
System.out.println("很遗憾，秒杀失败！");
}
}
}
}
效果展示：
ThreadLocal（线程变量）
ThreadLocal threadLocal = new ThreadLocal() {
@Override
protected Object initialValue() {
return 0;
}
};
ThreadLocal是用来为每个线程提供一个变量副本，每个线程中的变量是相互隔离的，所以称为本地线程变量。
ThreadLocal底层原理分析
set方法：
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
get方法：
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
看似只创建了一个ThreadLocal对象，实际上在每个ThreadLocal对象内部各自都创建了一个ThreadLocalMap，用来保存此线程拥有的变量。将ThreadLocal作为键，value作为值.
ThreadLocal内存泄露问题
ThreadLocal内存泄露问题造成原因：当本地变量不在线程中继续使用时，但是value值还与外界保持关系，这样一来垃圾回收器就不能回收ThreadLocalMap对象，会造成内存泄漏问题。
解决办法：用完之后删除threadLocal.remove();
下次垃圾回收时就可以回收ThreadLocalMap了。
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
扫一扫
6404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
