Java多线程（线程池原子性并发工具类）
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java多线程（线程池原子性并发工具类）相关的知识，希望对你有一定的参考价值。
1.线程池
1.1 线程状态介绍
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程
状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下：
public class Thread
public enum State
/* 新建 */
NEW ,
/* 可运行状态 */
RUNNABLE ,
/* 阻塞状态 */
BLOCKED ,
/* 无限等待状态 */
WAITING ,
/* 计时等待 */
TIMED_WAITING ,
/* 终止 */
TERMINATED;
// 获取当前线程的状态
public State getState()
return jdk.internal.misc.VM.toThreadState(threadStatus);
通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下
线程状态 | 具体含义 |
NEW | 一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。 |
RUNNABLE | 当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。 |
BLOCKED | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
WAITING | 一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。 |
TIMED_WAITING | 一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。 |
TERMINATED | 一个完全运行完成的线程的状态。也称之为终止状态、结束状态 |
各个状态的转换，如下图所示：
1.2 线程池-基本原理
概述 :
提到池，大家应该能想到的就是水池。水池就是一个容器，在该容器中存储了很多的水。那么什么是线程池呢？线程池也是可以看做成一个池子，在该池子中存储很多个线程。
线程池存在的意义：
系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系
统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就
会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。
线程池的设计思路 :
- 准备一个任务容器
- 一次性启动多个(2个)消费者线程
- 刚开始任务容器是空的，所以线程都在wait
- 直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒
- 这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来
1.3 线程池-Executors默认线程池
概述 : JDK对线程池也进行了相关的实现，在真实企业开发中我们也很少去自定义线程池，而是使用JDK中自带的线程池。
我们可以使用Executors中所提供的静态方法来创建线程池
static ExecutorService newCachedThreadPool() 创建一个默认的线程池
static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
代码实现 :
package com.itheima.mythreadpool;
//static ExecutorService newCachedThreadPool() 创建一个默认的线程池
//static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MyThreadPoolDemo
public static void main(String[] args) throws InterruptedException
//1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
ExecutorService executorService = Executors.newCachedThreadPool();
//Executors --- 可以帮助我们创建线程池对象
//ExecutorService --- 可以帮助我们控制线程池
executorService.submit(()->
System.out.println(Thread.currentThread().getName() + "在执行了");
);
//Thread.sleep(2000);
executorService.submit(()->
System.out.println(Thread.currentThread().getName() + "在执行了");
);
executorService.shutdown();
1.4 线程池-Executors创建指定上限的线程池
使用Executors中所提供的静态方法来创建线程池
static ExecutorService newFixedThreadPool(int nThreads) : 创建一个指定最多线程数量的线程池
代码实现 :
package com.itheima.mythreadpool;
//static ExecutorService newFixedThreadPool(int nThreads)
//创建一个指定最多线程数量的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
public class MyThreadPoolDemo2
public static void main(String[] args)
//参数不是初始值而是最大值
ExecutorService executorService = Executors.newFixedThreadPool(10);
ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
System.out.println(pool.getPoolSize());//0
executorService.submit(()->
System.out.println(Thread.currentThread().getName() + "在执行了");
);
executorService.submit(()->
System.out.println(Thread.currentThread().getName() + "在执行了");
);
System.out.println(pool.getPoolSize());//2
// executorService.shutdown();
1.5 线程池-ThreadPoolExecutor
创建线程池对象 :
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);
代码实现 :
package com.itheima.mythreadpool;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class MyThreadPoolDemo3
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位
// 参数五：任务队列
// 参数六：创建线程工厂
// 参数七：任务的拒绝策略
public static void main(String[] args)
ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
pool.submit(new MyRunnable());
pool.submit(new MyRunnable());
pool.shutdown();
1.6 线程池-参数详解
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
corePoolSize： 核心线程的最大值，不能小于0
maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize
keepAliveTime： 空闲线程最大存活时间,不能小于0
unit： 时间单位
workQueue： 任务队列，不能为null
threadFactory： 创建线程工厂,不能为null
handler： 任务的拒绝策略,不能为null
1.7 线程池-非默认任务拒绝策略
RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。
ThreadPoolExecutor.AbortPolicy: 丢弃任务并抛出RejectedExecutionException异常。是默认的策略。
ThreadPoolExecutor.DiscardPolicy： 丢弃任务，但是不抛出异常 这是不推荐的做法。
ThreadPoolExecutor.DiscardOldestPolicy： 抛弃队列中等待最久的任务 然后把当前任务加入队列中。
ThreadPoolExecutor.CallerRunsPolicy: 调用任务的run()方法绕过线程池直接执行。
注：明确线程池对多可执行的任务数 = 队列容量 + 最大线程数
案例演示1：演示ThreadPoolExecutor.AbortPolicy任务处理策略
public class ThreadPoolExecutorDemo01
public static void main(String[] args)
/**
* 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
*/
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;
// 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常
for(int x = 0 ; x < 5 ; x++)
threadPoolExecutor.submit(() ->
System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
);
控制台输出结果
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-3---->> 执行了任务
控制台报错，仅仅执行了4个任务，有一个任务被丢弃了
案例演示2：演示ThreadPoolExecutor.DiscardPolicy任务处理策略
public class ThreadPoolExecutorDemo02
public static void main(String[] args)
/**
* 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
*/
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardPolicy()) ;
// 提交5个任务，而该线程池最多可以处理4个任务，当我们使用DiscardPolicy这个任务处理策略的时候，控制台不会报错
for(int x = 0 ; x < 5 ; x++)
threadPoolExecutor.submit(() ->
System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
);
控制台输出结果
pool-1-thread-1---->> 执行了任务
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
控制台没有报错，仅仅执行了4个任务，有一个任务被丢弃了
案例演示3：演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略
public class ThreadPoolExecutorDemo02
public static void main(String[] args)
/**
* 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
*/
ThreadPoolExecutor threadPoolExecutor;
threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy());
// 提交5个任务
for(int x = 0 ; x < 5 ; x++)
// 定义一个变量，来指定指定当前执行的任务;这个变量需要被final修饰
final int y = x ;
threadPoolExecutor.submit(() ->
System.out.println(Thread.currentThread().getName() + "---->> 执行了任务" + y);
);
控制台输出结果
pool-1-thread-2---->> 执行了任务2
pool-1-thread-1---->> 执行了任务0
pool-1-thread-3---->> 执行了任务3
pool-1-thread-1---->> 执行了任务4
由于任务1在线程池中等待时间最长，因此任务1被丢弃。
案例演示4：演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略
public class ThreadPoolExecutorDemo04
public static void main(String[] args)
/**
* 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
*/
ThreadPoolExecutor threadPoolExecutor;
threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy());
// 提交5个任务
for(int x = 0 ; x < 5 ; x++)
threadPoolExecutor.submit(() ->
System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
);
控制台输出结果
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-1---->> 执行了任务
main---->> 执行了任务
通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。
2. 原子性
2.1 volatile-问题
代码分析 :
package com.itheima.myvolatile;
public class Demo
public static void main(String[] args)
MyThread1 t1 = new MyThread1();
t1.setName("小路同学");
t1.start();
MyThread2 t2 = new MyThread2();
t2.setName("小皮同学");
t2.start();
package com.itheima.myvolatile;
public class Money
public static int money = 100000;
package com.itheima.myvolatile;
public class MyThread1 extends Thread
@Override
public void run()
while(Money.money == 100000)
System.out.println("结婚基金已经不是十万了");
package com.itheima.myvolatile;
public class MyThread2 extends Thread
@Override
public void run()
try
Thread.sleep(10);
catch (InterruptedException e)
e.printStackTrace();
Money.money = 90000;
程序问题 : 女孩虽然知道结婚基金是十万，但是当基金的余额发生变化的时候，女孩无法知道最新的余额。
2.2 volatile解决
以上案例出现的问题 :
当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题
1，堆内存是唯一的，每一个线程都有自己的线程栈。
2 ，每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。
3 ，在线程中，每一次使用是从变量的副本中获取的。
Volatile关键字 : 强制线程每次在使用的时候，都会看一下共享区域最新的值
代码实现 : 使用volatile关键字解决
package com.itheima.myvolatile;
public class Demo
public static void main(String[] args)
MyThread1 t1 = new MyThread1();
t1.setName("小路同学");
t1.start();
MyThread2 t2 = new MyThread2();
t2.setName("小皮同学");
t2.start();
package com.itheima.myvolatile;
public class Money
public static volatile int money = 100000;
package com.itheima.myvolatile;
public class MyThread1 extends Thread
@Override
public void run()
while(Money.money == 100000)
System.out.println("结婚基金已经不是十万了");
package com.itheima.myvolatile;
public class MyThread2 extends Thread
@Override
public void run()
try
Thread.sleep(10);
catch (InterruptedException e)
e.printStackTrace();
Money.money = 90000;
2.3 synchronized解决
synchronized解决 :
1 ，线程获得锁
2 ，清空变量副本
3 ，拷贝共享变量最新的值到变量副本中
4 ，执行代码
5 ，将修改后变量副本中的值赋值给共享数据
6 ，释放锁
代码实现 :
package com.itheima.myvolatile2;
public class Demo
public static void main(String[] args)
MyThread1 t1 = new MyThread1();
t1.setName("小路同学");
t1.start();
MyThread2 t2 = new MyThread2();
t2.setName("小皮同学");
t2.start();
package com.itheima.myvolatile2;
public class Money
public static Object lock = new Object();
public static volatile int money = 100000;
package com.itheima.myvolatile2;
public class MyThread1 extends Thread
@Override
public void run()
while(true)
synchronized (Money.lock)
if(Money.money != 100000)
System.out.println("结婚基金已经不是十万了");
break;
package com.itheima.myvolatile2;
public class MyThread2 extends Thread
@Override
public void run()
synchronized (Money.lock)
try
Thread.sleep(10);
catch (InterruptedException e)
e.printStackTrace();
Money.money = 90000;
2.4 原子性
概述 : 所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。
代码实现 :
package com.itheima.threadatom;
public class AtomDemo
public static void main(String[] args)
MyAtomThread atom = new MyAtomThread();
for (int i = 0; i < 100; i++)
new Thread(atom).start();
class MyAtomThread implements Runnable
private volatile int count = 0; //送冰淇淋的数量
@Override
public void run()
for (int i = 0; i < 100; i++)
//1,从共享数据中读取数据到本线程栈中.
//2,修改本线程栈中变量副本的值
//3,会把本线程栈中变量副本的值赋值给共享数据.
count++;
System.out.println("已经送了" + count + "个冰淇淋");
代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断
2.5 volatile关键字不能保证原子性
解决方案 : 我们可以给count++操作添加锁，那么count++操作就是临界区中的代码，临界区中的代码一次只能被一个线程去执行，所以count++就变成了原子操作。
package com.itheima.threadatom2;
public class AtomDemo
public static void main(String[] args)
MyAtomThread atom = new MyAtomThread();
for (int i = 0; i < 100; i++)
new Thread(atom).start();
class MyAtomThread implements Runnable
private volatile int count = 0; //送冰淇淋的数量
private Object lock = new Object();
@Override
public void run()
for (int i = 0; i < 100; i++)
//1,从共享数据中读取数据到本线程栈中.
//2,修改本线程栈中变量副本的值
//3,会把本线程栈中变量副本的值赋值给共享数据.
synchronized (lock)
count++;
System.out.println("已经送了" + count + "个冰淇淋");
2.6 原子性_AtomicInteger
概述：java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变
量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。本次我们只讲解
使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：
AtomicBoolean： 原子更新布尔类型
AtomicInteger： 原子更新整型
AtomicLong： 原子更新长整型
以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：
public AtomicInteger()： 初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
int get(): 获取值
int getAndIncrement(): 以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet(): 以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data): 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value): 以原子方式设置为newValue的值，并返回旧值。
代码实现 :
package com.itheima.threadatom3;
import java.util.concurrent.atomic.AtomicInteger;
public class MyAtomIntergerDemo1
// public AtomicInteger()： 初始化一个默认值为0的原子型Integer
// public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
public static void main(String[] args)
AtomicInteger ac = new AtomicInteger();
System.out.println(ac);
AtomicInteger ac2 = new AtomicInteger(10);
System.out.println(ac2);
package com.itheima.threadatom3;
import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;
public class MyAtomIntergerDemo2
// int get(): 获取值
// int getAndIncrement(): 以原子方式将当前值加1，注意，这里返回的是自增前的值。
// int incrementAndGet(): 以原子方式将当前值加1，注意，这里返回的是自增后的值。
// int addAndGet(int data): 以原子方式将参数与对象中的值相加，并返回结果。
// int getAndSet(int value): 以原子方式设置为newValue的值，并返回旧值。
public static void main(String[] args)
// AtomicInteger ac1 = new AtomicInteger(10);
// System.out.println(ac1.get());
// AtomicInteger ac2 = new AtomicInteger(10);
// int andIncrement = ac2.getAndIncrement();
// System.out.println(andIncrement);
// System.out.println(ac2.get());
// AtomicInteger ac3 = new AtomicInteger(10);
// int i = ac3.incrementAndGet();
// System.out.println(i);//自增后的值
// System.out.println(ac3.get());
// AtomicInteger ac4 = new AtomicInteger(10);
// int i = ac4.addAndGet(20);
// System.out.println(i);
// System.out.println(ac4.get());
AtomicInteger ac5 = new AtomicInteger(100);
int andSet = ac5.getAndSet(20);
System.out.println(andSet);
System.out.println(ac5.get());
2.7 AtomicInteger-内存解析
AtomicInteger原理 : 自旋锁 + CAS 算法
CAS算法：
有3个操作数（内存值V， 旧的预期值A，要修改的值B）
当旧的预期值A == 内存值 此时修改成功，将V改为B
当旧的预期值A！=内存值 此时修改失败，不做任何操作
并重新获取现在的最新值（这个重新获取的动作就是自旋）
2.8 AtomicInteger-源码解析
代码实现 :
package com.itheima.threadatom4;
public class AtomDemo
public static void main(String[] args)
MyAtomThread atom = new MyAtomThread();
for (int i = 0; i < 100; i++)
new Thread(atom).start();
package com.itheima.threadatom4;
import java.util.concurrent.atomic.AtomicInteger;
public class MyAtomThread implements Runnable
//private volatile int count = 0; //送冰淇淋的数量
//private Object lock = new Object();
AtomicInteger ac = new AtomicInteger(0);
@Override
public void run()
for (int i = 0; i < 100; i++)
//1,从共享数据中读取数据到本线程栈中.
//2,修改本线程栈中变量副本的值
//3,会把本线程栈中变量副本的值赋值给共享数据.
//synchronized (lock)
// count++;
// ac++;
int count = ac.incrementAndGet();
System.out.println("已经送了" + count + "个冰淇淋");
//
源码解析 :
//先自增，然后获取自增后的结果
public final int incrementAndGet()
//+ 1 自增后的结果
//this 就表示当前的atomicInteger（值）
//1 自增一次
return U.getAndAddInt(this, VALUE, 1) + 1;
public final int getAndAddInt(Object o, long offset, int delta)
//v 旧值
int v;
//自旋的过程
do
//不断的获取旧值
v = getIntVolatile(o, offset);
//如果这个方法的返回值为false，那么继续自旋
//如果这个方法的返回值为true，那么自旋结束
//o 表示的就是内存值
//v 旧值
//v + delta 修改后的值
while (!weakCompareAndSetInt(o, offset, v, v + delta));
//作用：比较内存中的值，旧值是否相等，如果相等就把修改后的值写到内存中，返回true。表示修改成功。
// 如果不相等，无法把修改后的值写到内存中，返回false。表示修改失败。
//如果修改失败，那么继续自旋。
return v;
2.9 悲观锁和乐观锁
synchronized和CAS的区别 :
**相同点：**在多线程情况下，都可以保证共享数据的安全性。
**不同点：**synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每 次操作共享数据之前，都会上锁。（悲观锁）
cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。
如果别人修改过，那么我再次获取现在最新的值。
如果别人没有修改过，那么我现在直接修改共享数据的值.(乐观锁）
3. 并发工具类
3.1 并发工具类-Hashtable
Hashtable出现的原因 : 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。
代码实现 :
package com.itheima.mymap;
import java.util.HashMap;
import java.util.Hashtable;
public class MyHashtableDemo
public static void main(String[] args) throws InterruptedException
Hashtable<String, String> hm = new Hashtable<>();
Thread t1 = new Thread(() ->
for (int i = 0; i < 25; i++)
hm.put(i + "", i + "");
);
Thread t2 = new Thread(() ->
for (int i = 25; i < 51; i++)
hm.put(i + "", i + "");
);
t1.start();
t2.start();
System.out.println("----------------------------");
//为了t1和t2能把数据全部添加完毕
Thread.sleep(1000);
//0-0 1-1 ..... 50- 50
for (int i = 0; i < 51; i++)
System.out.println(hm.get(i + ""));
//0 1 2 3 .... 50
3.2 并发工具类-ConcurrentHashMap基本使用
ConcurrentHashMap出现的原因 : 在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。
基于以上两个原因我们可以使用JDK1.5以后所提供的ConcurrentHashMap。
体系结构 :
总结 :
1 ，HashMap是线程不安全的。多线程环境下会有数据安全问题
2 ，Hashtable是线程安全的，但是会将整张表锁起来，效率低下
3，ConcurrentHashMap也是线程安全的，效率较高。 在JDK7和JDK8中，底层原理不一样。
代码实现 :
package com.itheima.mymap;
import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;
public class MyConcurrentHashMapDemo
public static void main(String[] args) throws InterruptedException
ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>(100);
Thread t1 = new Thread(() ->
for (int i = 0; i < 25; i++)
hm.put(i + "", i + "");
);
Thread t2 = new Thread(() ->
for (int i = 25; i < 51; i++)
hm.put(i + "", i + "");
);
t1.start();
t2.start();
System.out.println("----------------------------");
//为了t1和t2能把数据全部添加完毕
Thread.sleep(1000);
//0-0 1-1 ..... 50- 50
for (int i = 0; i < 51; i++)
System.out.println(hm.get(i + ""));
//0 1 2 3 .... 50
3.3 并发工具类-ConcurrentHashMap1.7原理
3.4 并发工具类-ConcurrentHashMap1.8原理
总结 :
1，如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做。 在第一次添加元素的时候创建哈希表
2，计算当前元素应存入的索引。
3，如果该索引位置为null，则利用cas算法，将本结点添加到数组中。
4，如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表。
5，当链表的长度大于等于8时，自动转换成红黑树6，以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性
3.5 并发工具类-CountDownLatch
CountDownLatch类 :
方法 | 解释 |
public CountDownLatch(int count) | 参数传递线程数，表示等待线程数量 |
public void await() | 让线程等待 |
public void countDown() | 当前线程执行完毕 |
使用场景： 让某一条线程等待其他线程执行完毕之后再执行
代码实现 :
package com.itheima.mycountdownlatch;
import java.util.concurrent.CountDownLatch;
public class ChileThread1 extends Thread
private CountDownLatch countDownLatch;
public ChileThread1(CountDownLatch countDownLatch)
this.countDownLatch = countDownLatch;
@Override
public void run()
//1.吃饺子
for (int i = 1; i <= 10; i++)
System.out.println(getName() + "在吃第" + i + "个饺子");
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
countDownLatch.countDown();
package com.itheima.mycountdownlatch;
import java.util.concurrent.CountDownLatch;
public class ChileThread2 extends Thread
private CountDownLatch countDownLatch;
public ChileThread2(CountDownLatch countDownLatch)
this.countDownLatch = countDownLatch;
@Override
public void run()
//1.吃饺子
for (int i = 1; i <= 15; i++)
System.out.println(getName() + "在吃第" + i + "个饺子");
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
countDownLatch.countDown();
package com.itheima.mycountdownlatch;
import java.util.concurrent.CountDownLatch;
public class ChileThread3 extends Thread
private CountDownLatch countDownLatch;
public ChileThread3(CountDownLatch countDownLatch)
this.countDownLatch = countDownLatch;
@Override
public void run()
//1.吃饺子
for (int i = 1; i <= 20; i++)
System.out.println(getName() + "在吃第" + i + "个饺子");
//2.吃完说一声
//每一次countDown方法的时候，就让计数器-1
countDownLatch.countDown();
package com.itheima.mycountdownlatch;
import java.util.concurrent.CountDownLatch;
public class MotherThread extends Thread
private CountDownLatch countDownLatch;
public MotherThread(CountDownLatch countDownLatch)
this.countDownLatch = countDownLatch;
@Override
public void run()
//1.等待
try
//当计数器变成0的时候，会自动唤醒这里等待的线程。
countDownLatch.await();
catch (InterruptedException e)
e.printStackTrace();
//2.收拾碗筷
System.out.println("妈妈在收拾碗筷");
package com.itheima.mycountdownlatch;
import java.util.concurrent.CountDownLatch;
public class MyCountDownLatchDemo
public static void main(String[] args)
//1.创建CountDownLatch的对象，需要传递给四个线程。
//在底层就定义了一个计数器，此时计数器的值就是3
CountDownLatch countDownLatch = new CountDownLatch(3);
//2.创建四个线程对象并开启他们。
MotherThread motherThread = new MotherThread(countDownLatch);
motherThread.start();
ChileThread1 t1 = new ChileThread1(countDownLatch);
t1.setName("小明");
ChileThread2 t2 = new ChileThread2(countDownLatch);
t2.setName("小红");
ChileThread3 t3 = new ChileThread3(countDownLatch);
t3.setName("小刚");
t1.start();
t2.start();
t3.start();
总结 :
1. CountDownLatch(int count)：参数写等待线程的数量。并定义了一个计数器。
2. await()：让线程等待，当计数器为0时，会唤醒等待的线程
3. countDown()： 线程执行完毕时调用，会将计数器-1。
3.6 并发工具类-Semaphore
使用场景 :
可以控制访问特定资源的线程数量。
实现步骤 :
1，需要有人管理这个通道
2，当有车进来了，发通行许可证
3，当车出去了，收回通行许可证
4，如果通行许可证发完了，那么其他车辆只能等着
代码实现 :
package com.itheima.mysemaphore;
import java.util.concurrent.Semaphore;
public class MyRunnable implements Runnable
//1.获得管理员对象，
private Semaphore semaphore = new Semaphore(2);
@Override
public void run()
//2.获得通行证
try
semaphore.acquire();
//3.开始行驶
System.out.println("获得了通行证开始行驶");
Thread.sleep(2000);
System.out.println("归还通行证");
//4.归还通行证
semaphore.release();
catch (InterruptedException e)
e.printStackTrace();
package com.itheima.mysemaphore;
public class MySemaphoreDemo
public static void main(String[] args)
MyRunnable mr = new MyRunnable();
for (int i = 0; i < 100; i++)
new Thread(mr).start();
Java并发工具类原子类
前言
为保证计数器中count=+1的原子性，我们在前面使用的都是synchronized互斥锁方案，加锁独占访问的方式未免太过霸道，于是我们来介绍另一种解决原子性问题的无锁方案：原子变量。在正式介绍原子变量之前，我们先来总结下锁的不足，然后深入介绍原子变量。
锁的劣势
通过对共享变量加锁，使得获取到锁的线程可以采用独占方式来访问共享变量，并且对变量的修改对随后获取这个锁的其他线程都是可见的（Happens-Before规则）。
当多个线程同时请求锁时，对于没有获取到锁的线程将有可能被挂起并且在稍后才恢复运行（有时会选择自旋等待）。当线程恢复执行时，必须等待其他线程执行完它们的时间片后，才能被调度执行。我们需要知道，在挂起和恢复线程等过程中会存在着很大的开销，并且通常存在着较长时间的中断。
加锁方案在竞争激烈的情况下，其性能会由于上下文切换的开销和调度延迟而降低。而如果锁的持有时间非常短，那么在不恰当的时间请求锁时，线程休眠的代价将会不太划算。
加锁还存在一些缺点：
- 当一个线程正在等待锁时，它不能做任何其他事情。
- 如果一个线程在持有锁的情况下被延迟执行（例如发生了缺页错误、调度延迟、或者其他情况），那么所有需要这个锁的线程都无法执行下去。
- 如果被阻塞的线程优先级较高，而持有锁的线程优先级较低，那么将会导致优先级反转问题。
即使高优先级的线程可以抢先执行，但仍然需要等待锁被释放，从而导致它的优先级会降到低优先级线程的级别。 - 如果持有锁的线程被永久地阻塞（例如优于出现了无限循环，死锁，活锁或者其他活跃性问题），所有等待这个锁的线程就永远无法执行下去。
与锁相比，valatile变量是一种轻量级地同步机制，因为在使用这些变量时不会发生上下文切换或线程调度等操作。与锁一样虽然提供了可见性保证，但是volatile变量不能用于构建原子的复合操作。好消息是，下面我们将介绍的原子变量不仅提供了与volatile变量相同的内存语义，还支持原子的更新操作，比基于锁的方案有着更高的可伸缩性。
原子变量的实现原理: 硬件对并发的支持
硬件对并发的支持
独占锁是一项悲观技术，对于细粒度操作（例如计数器），还有另外一种更高效的方法，也是乐观方法，通过这种方法也可以在不受其他线程干扰的情况下完成更新操作。这种方法通过借助冲突检查机制来判断在更新过程中是否存在来自其他线程的干扰，如果存在，这个操作将失败，并且可以重新尝试（也可以不尝试）。
这种方法也就是处理器中提供的一些特殊指令（这些特殊指令本身可以保证原子性）。这些指令用于管理对共享数据的并发访问。
在早期的处理器中支持原子的测试并设置（Test-and-Set），获取并递增（Fetch-and-Increment）以及交换（Swap）等指令，这些指令足以实现各种互斥体，而这些互斥体又可以实现一些更加复杂的并发对象。
现在几乎所有的现代处理器都包含了某种形式的原子读-改-写指令，例如比较并交换（CAS，Compare-and-Swap）或者关联加载/条件存储（Load-Linked/Store-Conditional）。
操作系统和JVM使用这些指令来实现锁和并发的数据结构，在Java 5.0之前，Java类中还不能直接使用这些指令。
原子类由这些特殊的指令实现，所有其性能会比较高。
比较并交换
在大多数处理架构中，对上述方法的实现是实现一个比较并交换（CAS）之指令。（在其他处理器中，采用一对指令来实现相同的功能：关联加载与条件存储。）
CAS包含了3个操作数：需要读写的内存地址V，进行比较的值A和拟写入的新值B。
当且仅当V中的值等于A时，CAS才会通过原子方式用新值B来更新V中的值，否则不会执行任何操作。无论位置V的值是否等于A，都将返回V原有的值。
CAS是一项乐观的技术，它希望能成功地执行更新操作，并且如果有另一个线程在最近一次检查后更新了该变量，那么CAS能检测到这个错误。
以下的SimulatedCAS模拟代码说明CAS的语义，用来理解CAS的工作原理(^{[2]})。
public class SimulatedCAS {
private int value;
public synchronized int get() {
return value;
}
public synchronized int compareAndSwap(int expectedValue, int newValue) {
// 读取目前的value值
int oldValue = value;
// 比较目前value值是否等于期望值
if (oldValue == expectedValue)
value = newValue; // 如果相等，则更新value的值
return oldValue; // 返回写入之前的值
}
public synchronized boolean compareAndSet(int expectedValue, int newValue) {
return (expectedValue == compareAndSwap(expectedValue, newValue));
}
}当多个线程尝试使用CAS同时更新一个变量时，只有其中一个线程能够更新变量的值，而其他线程都将失败。但是，与获取锁实现的线程不一样，这里失败的线程并不会被挂起，而是被告知在这次竞争中失败，并可以再次尝试（或者选择不尝试，做一些其他恢复操作等）。这种方式的灵活性大大减少与锁相关的活跃性风险。
CAS的典型使用模式：首先从V中读取值A，并根据A计算新值B，然后在通过CAS以原子方式将V中的值由A变为B，前提是这个期间没有其他线程将V的值修改为其他值。
由于CAS能检测到来自其他线程的干扰，因此即使不用锁也能够实现原子的读-改-写操作。
非阻塞的计数器
下面我们使用CAS来实现一个线程安全的计数器。递增操作采用标准方式：读取旧值，根据它计算新值，并使用CAS来设置这个新值。如果CAS失败，那么该操作将立即重试。反复的重试也称为自旋。通常，反复地重试是一种合理的策略，但是在一些竞争激烈的情况下，最好的方式实在重试之前先等待一段时间或者回退，从而避免造成活锁问题。
下面基于“CAS+自旋”实现计数器(^{[2]})：
public class CasCounter {
private SimulatedCAS value;
public int getValue() {
return value.get();
}
public int increment() {
int v;
do {
v = value.get(); // 获取旧值
} while (v != value.compareAndSwap(v, v + 1)); // 自旋尝试
return v + 1;
}
}CasCounter不会阻塞，但是如果其他线程同时更新计数器，那么会多次执行重试操作。
这样看来，似乎基于CAS的计数器比基于锁的计数器性能要差一点，因为它需要执行更多的操作和更复杂的控制流。然而实际情况却并非如此。虽然Java语言的锁定语法简洁，但是JVM和操作在管理锁时需要完成的工作却并不简单，即使用锁简单，锁背后要做的工作却复杂。
在实现锁定时需要遍历JVM中一条非常复杂的代码路径，并可能导致操作系统级的锁定、线程挂起以及上下文切换等操作。并且，在最好情况下（获取无竞争的锁），在锁定时至少需要一次CAS，因此虽然在使用锁时没有用到CAS，但实际上也无法节约任何执行开销，也就是说会比CAS执行更多的操作。
在程序内部执行CAS时是不需要执行JVM代码、系统调用或者线程调度操作。在应用级别看起来越长的代码路径，如果加上JVM和操作系统中的代码调用，那么事实上却变得更短。
而CAS的主要缺点在于：它将使调用者来处理竞争问题（通过重试、回退和放弃），而在锁中能自动处理竞争问题（线程在获取锁之间将一直被阻塞）。
CAS的性能也会随着处理器数量的不同、体系架构的不同甚至处理器版本的不同而产生变化。
ABA问题
ABA问题是指：如果V的值首先由A变成了B，再由B变成了A，虽然V中的值A好像没有变，但是在某些算法中，A的属性却是变了。对于保护的变量是数值类型是不需要关心ABA问题，但是如果是对象，就需要注意。
一个相对简单的解决办法是：不是更新某个引用的值，而是更新两个值，包括一个引用和一个版本号。即使这个值由A变成了B，然后又变成了A，版本号也将是不同的。AtomicStampedReference和AtomicMarkableReference支持在两个变量上执行原子的条件更新。
AtomicStampedReference将更新一个“对象-引用”二元组，通过在引用上加上“版本号”，从而避免了ABA问题。
同样，AtomicMarkableReference将更新一个“对象引用-布尔值”二元组。
JVM对CAS的支持
在Java 5.0之前，如果不编写明确的代码，那么就无法执行CAS。在Java 5.0中引入了底层的支持，在int、long和对象的引用等类型上都公开了CAS操作，并且JVM把它们编译为底层硬件提供的最有效方法。在支持CAS的平台上，运行时把它们编译为相应的（多条）机器指令。在最坏情况下，如果不支持CAS指令，那么JVM将使用自旋锁。
在原子变量类（例如java.util.concurrent.atomic中的AtomicXxx）中使用了这些底层的JVM支持为数字类型和引用类型提供的一种高效的CAS操作，而在java.util.concurrent中的大多数类在实现时则直接或间接地使用了这些原子变量类。
原子类概览
Java JDK并发包中提供的原子类很丰富，可以分为五个类别：标量类（基本数据类）、对象引用类、数组类、对象属性更新器类和累加器类。
Java提供的原子类里面CAS一般被实现为compareAndSet()，compareAndSet()的语义和CAS指令语义的差别仅仅是返回值的不同，compareAndSet()里面如果更新成功，则会返回true，否则返回false。
do {
// 获取当前值
oldV = xxxx；
// 根据当前值计算新值
newV = ...oldV...
}while(!compareAndSet(oldV,newV);原子标量类（原子基本数据类）
相关实现类有AtomicBoolean、AtomicInteger和AtomicLong，提供的方法主如下：
getAndIncrement() // 原子化 i++
getAndDecrement() // 原子化的 i--
incrementAndGet() // 原子化的 ++i
decrementAndGet() // 原子化的 --i
// 当前值 +=delta，返回 += 前的值
getAndAdd(delta)
// 当前值 +=delta，返回 += 后的值
addAndGet(delta)
//CAS 操作，返回是否成功
compareAndSet(expect, update)
// 以下四个方法
// 新值可以通过传入 func 函数来计算
getAndUpdate(func)
updateAndGet(func)
getAndAccumulate(x,func)
accumulateAndGet(x,func)原子对象引用类
相关实现有AtomicReference、AtomicStampedReference和AtomicMarkableReference，利用它们可以实现对象引用的原子化更新。
AtomicReference提供的方法和原子化的基本数据类型差不多。不过，需要注意，对象引用的更新需要重点关注ABA问题，正如前面提过，AtomicStampedReference和AtomicMarkableReference这两个原子类可以解决ABA问题。
AtomicStampedReference实现的CAS方法增加的版本号参数，方法签名如下：
boolean compareAndSet(
V expectedReference,
V newReference,
int expectedStamp,
int newStamp)AtomicMarkableReference的实现机制更简单，将版本号简化成了一个Boolean值，方法签名如下：
boolean compareAndSet(
V expectedReference,
V newReference,
boolean expectedMark,
boolean newMark)原子数组类
相关实现有AtomicIntegerArray、AtomicLongArray和AtomicReferenceArray，利用这些原子类，我们可以原子化地更新数组中的每一个元素。
这些类提供的方法和原子化基本数据类型的区别仅仅是：每个方法多了一个数组的索引参数。
原子对象属性更新器类
相关实现有AtomicIntegerFieldUpdater、AtomicLongFieldUpdater和AtomicReferenceFieldUpdater。利用它们可以原子化地更新对象的属性，这三个方法都是利用反射机制实现的，创建更新器的方法如下：
public static <U> AtomicXXXFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName)需要注意，对象属性必须是volatile类型的，只有这样才能保证可见性；如果对象属性不是volatile类型的，newUpdater()方法会抛出IllegalArgumentException这个运行时异常。
newUpdater()方法的参数中只有类的信息没有对象的引用，而更新对象的属性，需要对象的引用，那么这个参数是再哪里传入的呢？
是在原子类操作的方法参数中传入的。例如，compareAndSet()这个原子操作，相比原子化的基本数据类型参数多了一个对象引用obj。
boolean compareAndSet(
T obj,
int expect,
int update)原子化对象属性更新器相关方法，相比原子类的基本数据类型仅仅是多了对象引用参数。
原子累加器类
DoubleAccumulator、DoubleAdder、LongAccumulator和LongAdder，这四个类仅仅用来执行累加计数操作，相比原子化的基本数据类型，速度更快，但是不支持compareAndSet()方法。
在实际情况中，如果仅需一个计数器或者序列生成器，那么可以直接使用AtomicInteger或者AtomicLong，它们能提供原子的递增方法以及其他算术方法。
小结
原子变量比锁的粒度更细，量级更轻。原子变量类也相当于一种泛化的volatile变量。原子变量较于锁来说，在性能和降低活跃性方面都表现很好，但是原子变量是将发生竞争的范围缩小到单个变量上，当需要解决多个共享变量的原子性问题，还是建议使用锁。
参考:
[1] 极客时间专栏王宝令《Java并发编程实战》
[2] Brian Goetz.Tim Peierls. et al.Java并发编程实战[M].北京:机械工业出版社,2016
以上是关于Java多线程（线程池原子性并发工具类）的主要内容，如果未能解决你的问题，请参考以下文章