JUC 并发编程学习笔记（狂神）
JUC 并发编程
视频链接：参考【狂神说Java】JUC并发编程最新版通俗易懂
文章目录
- JUC 并发编程
- 1 什么是 JUC
- 2 线程和进程
-
- 2.1 什么是线程
- 2.2 并发与并行
-
- 2.3 wait/sleep 的区别
- 3 Lock
-
- 3.1 使用 synchroniezd 关键字加锁
- 3.2 使用 Lock 类加锁
- 3.3 Synchronized 与Lock 的区别
- 4. 生产者和消费者的关系
-
- 4.1 Synchronized 版本
- 4.2 Lock 版本
- 五、8 锁现象
- 六 集合不安全
-
- 6.1 List 不安全
- 6.2 set 不安全
- 6.3 Map 不安全
- 七 Callable
- 八 常用辅助类
-
- 8.1 CountDownLatch
- 8.2 CyclickBarrier
- 8.3 Semaphore
- 九 读写锁
- 十 阻塞队列
-
- 10.1 BlockQueue
- 10.2 同步队列
- 十一 线程池
-
- 11.1 线程池的好处：
- 11.2 线程池：三大方法
- 11.3 七大参数
- 11.4 拒绝策略
- 11.5 如何设置线程池的大小
- 十二 四大函数式接口
-
- 12.1 Function 函数型接口
- 12.2 Predicate 断定型接口
- 12.3 Suppier 供给型接口
- 12.4 Consummer 消费型接口
- 十三 Stream流式计算
- 14 ForkJoin
-
- 14.1 ForkJoin 特点：工作窃取！
- 14.2 如何使用ForkJoin？
- 十五 异步回调
-
- 15.1 没有返回值的runAsync异步回调
- 15.2 有返回值的异步回调supplyAsync
- 十六 JMM
- 16.1 对 Voatile 的理解
-
- 16.2 什么是 JMM ？
- 十七 volitile
-
- 17.1保证可见性
- 17.2 不保证原子性
- 17.3 禁止指令重排
- 17.4 总结
- 十八 玩转单例模式
-
- 18.1 饿汉式
- 18.2 DCL 懒汉式
- 18.3 静态内部类
- 18.4 枚举
- 十九 深入理解CAS
-
- 19.1 什么是CAS？
- 19.2 总结
- 20. 原子引用
- 二十一 各种锁的理解
-
- 21.1 公平锁，非公平锁
- 21.2 可重入锁
- 21.3 自旋锁
- 21.4 死锁
1 什么是 JUC
JUC 就是 java.util.concurrent 下面的类包，专门用于多线程的开发。
2 线程和进程
2.1 什么是线程
线程是进程中的一个实体，线程本身是不会独立存在的。
进程是代码在数据集合上的一次运行活动， 是系统进行资源分配和调度的基本单位。
线程则是进程的一个执行路径， 一个进程中至少有一个线程，进程中的多个线程共享进程的资源。
操作系统在分配资源时是把资源分配给进程的， 但是CPU 资源比较特殊， 它是被分配到线程的， 因为真正要占用C PU 运行的是线程， 所以也说线程是CPU 分配的基本单位。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UDB6nUOZ-1606918113424)(C:\Users\10511\AppData\Roaming\Typora\typora-user-images\1606133719007.png)]
Java 默认有 2 线程 ！（mian 线程、GC 线程）
Java 中，使用 Thread、Runnable、Callable 开启线程。
Java 没有权限开启线程 、Thread.start() 方法调用了一个 native 方法 start0()，它调用了底层 C++ 代码。
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
// Java 没有权限操作底层硬件的
private native void start0();
2.2 并发与并行
并发是指同一个时间段内多个任务同时都在执行，并都没有执行结束。
并行是说在单位时间内多个任务同时在执行。
在单 CPU 时代，多个任务都是并发执行的，这是因为单个 CPU 同时只能执行一个任务。
多个 CPU 意味着每个线程可以使用自己的 CPU 运行，这减少了上下文切换的开销，但随着对应用系统性能核吞吐量要求的提高，出现了处理海量数据核请求的要求，这些都对高并发编程有着迫切的需求。
获取 CPU 的核数(虚拟内核)
System.out.println(Runtime.getRuntime().availableProcessors());
线程的状态
public enum State {
NEW,
RUNNABLE,
BLOCKED,
//等待
WAITING,
//超时等待
TIMED_WAITING,
TERMINATED;
}
2.3 wait/sleep 的区别
① 来自不同的类
wait ->Object
sleep->Thread
企业中使用休眠的一般方式：
TimeUnit.DAYS.sleep(1);// 休眠一天
TimeUnit.SECONDS.sleep(1);// 休眠一秒
②关于锁的释放
wait 释放锁；
sleep 不释放锁；（抱着锁睡）
③使用范围不同
wait 必须在同步代码块中；
sleep 可以在任何地方；
④是否需要捕获异常
wait 不需要捕获异常；
sleep 必须要捕获异常；
3 Lock
3.1 使用 synchroniezd 关键字加锁
package com.sjmp.demo01;
/**
* @author: sjmp1573
* @date: 2020/11/23 21:09
* @description:
*/
public class Demo02 {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(()->{
for (int i = 0; i < 200; i++) {
ticket.sale();
}
}).start();
new Thread(()->{
for (int i = 0; i < 100; i++) {
ticket.sale();
}
}).start();
new Thread(()->{
for (int i = 0; i < 100; i++) {
ticket.sale();
}
}).start();
}
}
// 这是一个资源类
class Ticket{
private int number = 300;
public synchronized void sale(){
if(number>0){
System.out.println(Thread.currentThread().getName()+"get "+number+"#");
number--;
}
}
}
3.2 使用 Lock 类加锁
ReentrantLock 默认的构造方法是非公平锁（可以插队）。
如果在构造方法中传入 true 则构造公平锁（不可以插队，先来后到）。
package com.sjmp.lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author: sjmp1573
* @date: 2020/11/23 21:24
* @description:
*/
public class demo01 {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(()->{
for (int i = 0; i < 200; i++) {
ticket.sale();
}
}).start();
new Thread(()->{
for (int i = 0; i < 100; i++) {
ticket.sale();
}
}).start();
new Thread(()->{
for (int i = 0; i < 100; i++) {
ticket.sale();
}
}).start();
}
}
// 这是一个资源类
class Ticket{
private int number = 300;
/*
* 1. 创建锁
* 2. 加锁
* 3. 解锁
* */
ReentrantLock reentrantLock = new ReentrantLock();
public void sale(){
reentrantLock.lock();
try {
if(number>0){
System.out.println(Thread.currentThread().getName()+"get "+number+"#");
number--;
}
} finally {
reentrantLock.unlock();
}
}
}
3.3 Synchronized 与Lock 的区别
① Synchronized 是 Java 内置关键字，Lock 是一个 Java 类
② Synchronied无法判断取锁的状态，Lock 可以判断
③ Synchronied 会自动释放锁，Lock 必须要手动加锁和手动释放锁！可能会遇到死锁
④ Synchronized 线程1(获得锁->阻塞)、线程2(等待)；lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。
⑤ Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；
⑥ Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；
注： “广义上的可重入锁指的是可重复可递归调用的锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁(前提得是同一个对象或者class),这样的锁就叫做可重入锁。“
4. 生产者和消费者的关系
4.1 Synchronized 版本
package com.sjmp.demo02PC;
/**
* @author: sjmp1573
* @date: 2020/11/24 18:54
* @description:
*/
public class ConsumeAndProduct {
public static void main(String[] args) {
Data data = new Data();
// 创建一个生产者
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
// 创建一个消费者
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
}
}
//这是一个缓冲类，生产和消费之间的仓库
class Data{
// 这是仓库的资源，生产者生产资源，消费者消费资源
private int num = 0;
// +1，利用关键字加锁
public synchronized void increment() throws InterruptedException {
// 首先查看仓库中的资源(num)，如果资源不为0，就利用 wait 方法等待消费，释放锁
if(num!=0){
this.wait();
}
num++;
System.out.println(Thread.currentThread().getName()+"=>"+num);
// 通知其他线程 +1 执行完毕
this.notifyAll();
}
// -1
public synchronized void decrement() throws InterruptedException {
// 首先查看仓库中的资源(num)，如果资源为0，就利用 wait 方法等待生产，释放锁
if(num==0){
this.wait();
}
num--;
System.out.println(Thread.currentThread().getName()+"=>"+num);
// 通知其他线程 -1 执行完毕
this.notifyAll();
}
}
上述方式存在的问题（虚假唤醒）
若有四个线程，则会出现虚假唤醒
解决办法： if 改为 while，防止虚假唤醒
结论：就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。
这也就是为什么用while而不用if的原因了，因为线程被唤醒后，执行开始的地方是wait之后
package com.sjmp.demo02PC;
/**
* @author: sjmp1573
* @date: 2020/11/24 18:54
* @description:
*/
public class ConsumeAndProduct {
public static void main(String[] args) {
Data data = new Data();
// 创建一个生产者
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
// 创建一个消费者
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
// 创建一个生产者
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
// 创建一个消费者
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
//这是一个缓冲类，生产和消费之间的仓库
class Data{
// 这是仓库的资源，生产者生产资源，消费者消费资源
private int num = 0;
// +1，利用关键字加锁
public synchronized void increment() throws InterruptedException {
// 首先查看仓库中的资源(num)，如果资源不为0，就利用 wait 方法等待消费，释放锁
// 使用 if 存在虚假唤醒
while (num!=0){
this.wait();
}
num++;
System.out.println(Thread.currentThread().getName()+"=>"+num);
// 通知其他线程 +1 执行完毕
this.notifyAll();
}
// -1
public synchronized void decrement() throws InterruptedException {
// 首先查看仓库中的资源(num)，如果资源为0，就利用 wait 方法等待生产，释放锁
while(num==0){
this.wait();
}
num--;
System.out.println(Thread.currentThread().getName()+"=>"+num);
// 通知其他线程 -1 执行完毕
this.notifyAll();
}
}
4.2 Lock 版本
package com.sjmp.demo02PC;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author: sjmp1573
* @date: 2020/11/24 19:26
* @description:
*/
public class LockImp {
public static void main(String[] args) {
Data2 data = new Data2();
// 创建一个生产者
new Thread(()->{
for (int i = 0; i < 15; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
// 创建一个消费者
new Thread(()->{
for (int i = 0; i < 15; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
// 创建一个生产者
new Thread(()->{
for (int i = 0; i < 15; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
// 创建一个消费者
new Thread(()->{
for (int i = 0; i < 15; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
//这是一个缓冲类，生产和消费之间的仓库
class Data2{
// 这是仓库的资源，生产者生产资源，消费者消费资源
private int num = 0;
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
// +1，利用可重入锁加锁
public void increment() throws InterruptedException {
// 首先查看仓库中的资源(num)，如果资源不为0，就利用 wait 方法等待消费，释放锁
lock.lock();
try {
// 使用 if 存在虚假唤醒
while (num!=0){
condition.await();
}
num++;
System.out.println(Thread.currentThread().getName()+"=>"+num);
// 通知其他线程 +1 执行完毕
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
// -1
public void decrement() throws InterruptedException {
lock.lock();
// 首先查看仓库中的资源(num)，如果资源为0，就利用 wait 方法等待生产，释放锁
try {
while(num==0){
condition.await();
}
num--;
System.out.println(Thread.currentThread().getName()+"=>"+num);
// 通知其他线程 -1 执行完毕
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
Condition 的优势
精准的通知和唤醒线程！
举例：指定通知下一个进行顺序。
package com.sjmp.demo02PC;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* A -> B -> C -> A
* @author: sjmp1573
* @date: 2020/11/24 19:39
* @description:
*/
public class ConditionDemo {
public static void main(String[] args) {
Data3 data3 = new Data3();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data3.printA();
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data3.printB();
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data3.printC();
}
},"C").start();
}
}
class Data3{
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
private int num = 1; // 1A 2B 3C
public void printA(){
lock.lock();
try {
// 业务代码 判断 -> 执行 -> 通知
while (num != 1){
condition1.await();
}
System.out.println(Thread.currentThread().getName()+" Im A ");
num = 2;
condition2.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try {
// 业务代码 判断 -> 执行 -> 通知
while (num != 2){
condition2.await();
}
System.out.println(Thread.currentThread().getName()+" Im B ");
num = 3;
condition3.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try {
// 业务代码 判断 -> 执行 -> 通知
while (num != 3){
condition3.await();
}
System.out.println(Thread.currentThread().getName()+" Im C ");
num = 1;
condition1.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
五、8 锁现象
深入理解锁！
问题1
两个同步方法，先执行发短信还是打电话？
package com.sjmp.demo03Lock8;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/11/24 19:56
* @description:
*/
public class demo01 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendMsg();
}).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
}).start();
}
}
// 可视作资源类
class Phone{
public synchronized void sendMsg(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
输出结果为:
发短信
打电话
为什么？ 如果你认为是顺序在前？ 这个答案是错误的！
问题2
我们再来看：我们让发短信 延迟2s
package com.sjmp.demo03Lock8;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/11/24 19:56
* @description:
*/
public class demo01 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendMsg();
}).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
}).start();
}
}
// 可视作资源类
class Phone{
public synchronized void sendMsg(){
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
分析：
原因：并不是顺序执行，而是synchronized 锁住的对象是方法的调用！对于两个方法用的是同一个锁，谁先拿到谁先执行，另外一个等待
问题3
加一个普通方法
package com.sjmp.demo03Lock8;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/11/24 19:56
* @description:
*/
public class demo01 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendMsg();
}).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.hello();
}).start();
}
}
// 可视作资源类
class Phone{
public synchronized void sendMsg(){
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
输出结果：
hello
发短信
原因：hello 是一个普通方法，不受 synchronized 锁的影响，不用等待锁释放。
问题4
两个对象，一个调用发短信，一个调用打电话。
package com.sjmp.demo03Lock8;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/11/24 19:56
* @description:
*/
public class demo01 {
public static void main(String[] args) {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone1.sendMsg();
}).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
}).start();
}
}
// 可视作资源类
class Phone{
public synchronized void sendMsg(){
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
输出结果：
打电话
发短信
分析：两个对象两把锁，phone2 对象拿到其锁后打电话，phone1 对象拿到其锁后等待 3s 发短信。
问题5、6
如果把 synchronized 方法加上 static 变成静态方法！
（1）我们先来使用一个对象调用两个方法！
答案是：先发短信,后打电话
（2）如果我们使用两个对象调用两个方法！
答案是：还是先发短信，后打电话
原因是什么呢？ 为什么加了static就始终前面一个对象先执行呢！为什么后面会等待呢？
原因是：对于static静态方法来说，对于整个类Class来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个对象！不管多少个对象，对于静态的锁都只有一把锁，谁先拿到这个锁就先执行，其他的进程都需要等待！
问题7
如果使用一个静态同步方法、一个同步方法、一个对象调用。
package com.sjmp.demo03Lock8;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/11/24 19:56
* @description:
*/
public class demo01 {
public static void main(String[] args) {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone1.sendMsg();
}).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone1.call();
}).start();
}
}
// 可视作资源类
class Phone{
public static synchronized void sendMsg(){
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
输出结果：
打电话
发短信
分析： 因为一个锁的是Class类的模板，一个锁的是对象的调用者。所以不存在等待，直接运行。
问题8
如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么？
输出结果：
打电话
发短信
分析：两把锁锁的不是同一东西
小节：
new 出来的 this 是具体的一个对象
static Class 是唯一的一个模板
六 集合不安全
6.1 List 不安全
package com.sjmp.demo04ListUnsafe;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* @author: sjmp1573
* @date: 2020/11/24 20:35
* @description:
*/
//java.util.ConcurrentModificationException
public class ListTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0, 5));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
ArrayList 在并发情况下是不安全的
会导致java.util.ConcurrentModificationException并发修改异常！
解决方案：
package com.sjmp.demo04ListUnsafe;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* @author: sjmp1573
* @date: 2020/11/24 20:35
* @description:
*/
//java.util.ConcurrentModificationException
public class ListTest {
/*
* 解决 ArrayList 并发修改异常的方案
* 1.List list = new Vector<>();
* 2.List list = Collections.synchronizedList(new ArrayList<>());
* 3.List list = new CopyOnWriteArrayList<>();
* */
public static void main(String[] args) {
List<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10; i++) {
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0, 5));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
CopyOnWriteArrayList：写入时复制！
核心思想是，如果有多个调用者（Callers）同时要求相同的资源（如内存或者是磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者视图修改资源内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。这过程对其他的调用者都是透明的（transparently）。此做法主要的优点是如果调用者没有修改资源，就不会有副本（private copy）被创建，因此多个调用者只是读取操作时可以共享同一份资源。
读的时候不需要加锁，如果读的时候有多个线程正在向CopyOnWriteArrayList添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的CopyOnWriteArrayList。
多个线程调用的时候，list，读取的时候，固定的，写入（存在覆盖操作）；在写入的时候避免覆盖，造成数据错乱的问题；
CopyOnWriteArrayList 比 Vector厉害在哪里？
Vector底层是使用synchronized关键字来实现的：效率特别低下。
CopyOnWriteArrayList使用的是Lock锁，效率会更加高效！
6.2 set 不安全
Set 和 List 同理可得：多线程情况下，普通的 Set 集合是线程不安全的；
解决方案有两种；
- 使用 Collection 工具类的 synchronized 包装的 Set 类
- 使用CopyOnWriteArraySet 写入复制的 JUC 解决方案
package com.sjmp.demo04ListUnsafe;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
/**
* @author: sjmp1573
* @date: 2020/11/24 21:07
* @description:
*/
public class SetTest {
public static void main(String[] args) {
/*
* 1.Set set = Collections.synchronizedSet(new HashSet<>());
* 2.Set set = new CopyOnWriteArraySet<>();
* */
Set<String> set = new CopyOnWriteArraySet<>();
for (int i = 0; i < 30; i++) {
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
HashSet 底层到底是什么？
hashSet底层就是一个HashMap；
6.3 Map 不安全
//map 是这样用的吗？ 不是，工作中不使用这个
//默认等价什么？ new HashMap<>(16,0.75);
Map<String, String> map = new HashMap<>();
//加载因子、初始化容量
默认加载因子是0.75,默认的初始容量是16
同样的HashMap基础类也存在并发修改异常！
package com.sjmp.demo04ListUnsafe;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author: sjmp1573
* @date: 2020/11/24 21:20
* @description:
*/
public class MapTest {
public static void main(String[] args) {
/*
* 1.map 是这样用的吗？ 不是，工作中不使用这个
* 默认等价什么？ new HashMap<>(16,0.75);
*
* 解决方案
* 1. Map map = Collections.synchronizedMap(new HashMap<>());
* Map map = new ConcurrentHashMap<>();
* */
ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
// 加载因子、初始化容量
for (int i = 0; i < 100; i++) {
new Thread(()->{
concurrentHashMap.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
System.out.println(concurrentHashMap);
},String.valueOf(i)).start();
}
}
}
TODO:研究ConcurrentHashMap底层原理：
七 Callable
-
可以有返回值
-
可以抛出异常
-
方法不同，run()/call()
package com.sjmp.demo05Callable; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * @author: sjmp1573 * @date: 2020/11/24 21:41 * @description: */ public class CallableTest { public static void main(String[] args) { Thread01 thread01 = new Thread01(); FutureTask<Integer> futureTask = new FutureTask<>(thread01); new Thread(futureTask).start(); try { // 放入Thread中使用，结果会被缓存 Integer integer = futureTask.get(); System.out.println(integer); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } } class Thread01 implements Callable<Integer>{ @Override public Integer call() throws Exception { System.out.println("success in call"); return 1024; } }
八 常用辅助类
8.1 CountDownLatch
package com.sjmp.demo08Helper;
import java.util.concurrent.CountDownLatch;
/**
* @author: sjmp1573
* @date: 2020/11/24 21:51
* @description:
*/
public class CountDownLatchDemo {
public static void main(String[] args) {
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 1; i < 6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"==>Go Out");
countDownLatch.countDown(); //每个线程都数量-1
},String.valueOf(i)).start();
}
try {
countDownLatch.await();// 等待计数器归零，然后向下执行
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("close door");
}
}
主要方法：
- countDown 减一操作；
- await 等待计数器归零；
await 等待计数器归零，就唤醒，再继续向下运行 。
8.2 CyclickBarrier
package com.sjmp.demo08Helper;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
* @author: sjmp1573
* @date: 2020/11/24 22:01
* @description:
*/
public class CyclicBarrierDemo {
public static void main(String[] args) {
// 主线程
CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
System.out.println("召唤神龙");
});
for (int i = 1; i <= 7; i++) {
// 子线程
int finalI = i;
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"收集了第"+finalI+"颗龙珠");
try {
cyclicBarrier.await();//加法计数等待
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
8.3 Semaphore
package com.sjmp.demo08Helper;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/11/24 22:11
* @description:
*/
public class SemaphoreDemo {
public static void main(String[] args) {
// 线程数量，停车位，限流
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i <=6 ; i++) {
new Thread(()->{
// acquire()得到
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"抢到车位");
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();
}
}).start();
}
}
}
Thread-0抢到车位
Thread-6抢到车位
Thread-4抢到车位
Thread-6离开车位
Thread-4离开车位
Thread-0离开车位
Thread-1抢到车位
Thread-3抢到车位
Thread-5抢到车位
Thread-3离开车位
Thread-5离开车位
Thread-1离开车位
Thread-2抢到车位
Thread-2离开车位
原理：
semaphore.acquire()获得资源，如果资源已经使用完了，就等待资源释放后再进行使用！
semaphore.release()释放，会将当前的信号量释放+1，然后唤醒等待的线程！
作用： 多个共享资源互斥的使用！ 并发限流，控制最大的线程数！
九 读写锁
package com.sjmp.demo08Helper.demo09ReadWriteLock;
import java.util.HashMap;
import java.util.Map;
/**
* @author: sjmp1573
* @date: 2020/11/24 22:20
* @description:
*/
public class ReadWriteLockDemo {
public static void main(String[] args) {
// 线程操作资源类
MyCache myCache = new MyCache();
int num = 6;
for (int i = 1; i < num; i++) {
int finalI = i;
new Thread(()->{
myCache.write(String.valueOf(finalI),String.valueOf(finalI));
},String.valueOf(i)).start();
}
for (int i = 1; i < num; i++) {
int finalI = i;
new Thread(()->{
myCache.read(String.valueOf(finalI));
},String.valueOf(i)).start();
}
}
}
/*
* 自定义缓存
*
* */
class MyCache{
private volatile Map<String,String> map = new HashMap<>();
// 存，写
public void write(String key,String value){
System.out.println(Thread.currentThread().getName()+"线程开始写入");
map.put(key,value);
System.out.println(Thread.currentThread().getName()+"线程开始写入ok");
}
// 取，读
public void read(String key){
System.out.println(Thread.currentThread().getName()+"线程开始读取");
map.get(key);
System.out.println(Thread.currentThread().getName()+"线程读取ok");
}
}
所以如果我们不加锁，多线程读写会造成写的时候出现问题。
我们也可以采用 synchronized 这种重量锁和 lock 去保证数据的可靠。
这次使用读写锁来实现
package com.sjmp.demo08Helper.demo09ReadWriteLock;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* @author: sjmp1573
* @date: 2020/11/24 22:20
* @description:
*/
public class ReadWriteLockDemo {
public static void main(String[] args) {
// 线程操作资源类
MyCache myCache = new MyCache();
int num = 6;
for (int i = 1; i < num; i++) {
int finalI = i;
new Thread(()->{
myCache.write(String.valueOf(finalI),String.valueOf(finalI));
},String.valueOf(i)).start();
}
for (int i = 1; i < num; i++) {
int finalI = i;
new Thread(()->{
myCache.read(String.valueOf(finalI));
},String.valueOf(i)).start();
}
}
}
/*
* 自定义缓存
*
* */
class MyCache{
private volatile Map map = new HashMap<>();
private ReadWriteLock lock = new ReentrantReadWriteLock();
// 存，写
public void write(String key,String value){
lock.writeLock().lock();//写锁
try {
System.out.println(Thread.currentThread().getName()+"线程开始写入");
map.put(key,value);
System.out.println(Thread.currentThread().getName()+"线程开始写入ok");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.writeLock().unlock();
}
}
// 取，读
public void read(String key){
lock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"线程开始读取");
map.get(key);
System.out.println(Thread.currentThread().getName()+"线程读取ok");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.readLock().unlock();
}
}
}
十 阻塞队列
10.1 BlockQueue
阻塞队列 BlockQueue 是Collection 的一个子类
应用场景：多线程并发处理、线程池
BlockingQueue 有四组 API
| 方式 | 抛出异常 | 不会抛出异常 | 阻塞等待 | 超时等待 |
|---|---|---|---|---|
| 添加 | add | offer | put | offer（timenum,timeUnit） |
| 移出 | remove | poll | take | poll（timenum,timeUnit） |
| 判断队首元素 | element | peek | - | - |
package com.sjmp.demo10BlockingQueue;
import org.junit.Test;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/11/25 22:07
* @description:
*/
/*
* 抛出异常
* add、remove、element
* */
public class BlockingQueueDemo {
@Test
public void test01(){
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.add("a"));
System.out.println(blockingQueue.add("b"));
System.out.println(blockingQueue.add("c"));
// 抛出异常 java.lang.IllegalStateException: Queue full
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
// 如果移除一个
// 这也会造成 java.util.NoSuchElementException
}
/*
* 不抛出异常，offer、poll、peek
* */
@Test
public void test02(){
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
// 添加不会抛出异常，返回false
System.out.println(blockingQueue.offer("d"));
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
// 移除不会抛出异常，返回null
System.out.println(blockingQueue.poll());
}
/*
* 等待，一直阻塞
* */
@Test
public void test03() throws InterruptedException {
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
// 一直阻塞，不会返回值
blockingQueue.put("a");
blockingQueue.put("b");
blockingQueue.put("c");
// 若队列已满，再添加，则阻塞等待添加,返回被取出的值
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
// 移除不会抛出异常，返回null
}
/*
* 超时等待
* 这种情况也会发生阻塞等待，但会超时结束
* */
@Test
public void test04() throws InterruptedException {
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
blockingQueue.offer("a");
blockingQueue.offer("b");
blockingQueue.offer("c");
System.out.println("开始等待");
blockingQueue.offer("d",2, TimeUnit.SECONDS);
System.out.println("等待结束");
System.out.println("=================取值=====================");
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println("取值开始等待");
blockingQueue.poll(2,TimeUnit.SECONDS);//超过两秒，我们就不等待了
System.out.println("取值结束等待");
}
}
10.2 同步队列
同步队列没有容量，也可以视为容量为 1 的队列；
进去一个元素，必须等待取出来之后，才能再往里面放入一个元素；
put 方法和 take 方法；
Synchronized 和 其他的BlockingQueue 不一样 它不存储元素；
put了一个元素，就必须从里面先take出来，否则不能再put进去值！
并且SynchronousQueue 的take是使用了lock锁保证线程安全的。
package com.sjmp.demo10BlockingQueue;
/**
* @author: sjmp1573
* @date: 2020/12/1 19:19
* @description:
*/
public class SynchronousQueue {
public static void main(String[] args) {
java.util.concurrent.SynchronousQueue<String> synchronousQueue = new java.util.concurrent.SynchronousQueue<>();
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"put 01");
synchronousQueue.put("1");
System.out.println(Thread.currentThread().getName()+"put 02");
synchronousQueue.put("2");
System.out.println(Thread.currentThread().getName()+"put 03");
synchronousQueue.put("3");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"take"+synchronousQueue.take());
System.out.println(Thread.currentThread().getName()+"take"+synchronousQueue.take());
System.out.println(Thread.currentThread().getName()+"take"+synchronousQueue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
Thread-0put 01
Thread-1take1
Thread-0put 02
Thread-1take2
Thread-0put 03
Thread-1take3
Process finished with exit code 0
十一 线程池
线程池：三大方式、七大参数、四种拒绝策略
池化技术
程序的运行，本质：占用系统的资源！优化资源的使用==> 池化技术
线程池、JDBC 连接池、内存池、对象池等等。
资源的创建、销毁十分消耗资源
池化技术：事先准备好一些资源，如果有人要用，就来我这里拿，用完之后还给我，以此来提高效率。
11.1 线程池的好处：
-
降低资源的消耗；
-
提高响应速度；
-
方便管理；
线程复用、可以控制最大并发数、管理线程；
11.2 线程池：三大方法
- ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
- ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
- ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的
package com.sjmp.demo11ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author: sjmp1573
* @date: 2020/12/1 19:36
* @description:
*/
public class Demo01 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();
ExecutorService threadPool2 = Executors.newFixedThreadPool(5);
ExecutorService threadPool3 = Executors.newCachedThreadPool();
// 线程池用完必须要关闭线程池
try {
for (int i = 0; i < 100; i++) {
// 通过线程池创建线程
threadPool3.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok");
});
}
} catch (Exception e) {
e.printStackTrace();
}finally {
threadPool3.shutdown();
}
}
}
11.3 七大参数
public ThreadPoolExecutor(int corePoolSize, //核心线程池大小
int maximumPoolSize, //最大的线程池大小
long keepAliveTime, //超时了没有人调用就会释放
TimeUnit unit, //超时单位
BlockingQueue<Runnable> workQueue, //阻塞队列
ThreadFactory threadFactory, //线程工厂 创建线程的 一般不用动
RejectedExecutionHandler handler //拒绝策略
) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
阿里巴巴的Java操作手册中明确说明：对于Integer.MAX_VALUE初始值较大，所以一般情况我们要使用底层的ThreadPoolExecutor来创建线程池。
package com.sjmp.demo11ThreadPool;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/12/1 19:48
* @description:
*/
public class PollDemo {
public static void main(String[] args) {
// 获取 cpu 的核数
int availableProcessors = Runtime.getRuntime().availableProcessors();
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
2,
availableProcessors,
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()
);
try {
for (int i = 0; i < 10; i++) {
threadPoolExecutor.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPoolExecutor.shutdown();
}
}
}
11.4 拒绝策略
- new ThreadPoolExecutor.AbortPolicy: // 该 拒绝策略为：银行满了，还有人进来，不处理这个人的，并抛出异常
- new ThreadPoolExecutor.CallerRunsPolicy(): // //该拒绝策略为：哪来的去哪里 main线程进行处理
- new ThreadPoolExecutor.DiscardPolicy(): //该拒绝策略为：队列满了,丢掉异常，不会抛出异常。
- new ThreadPoolExecutor.DiscardOldestPolicy()： //该拒绝策略为：队列满了，尝试去和最早的进程竞争，不会抛出异常
11.5 如何设置线程池的大小
- CPU 密集型：电脑的核数是几核就选几；选择maximunPoolSize 的大小
// 获取cpu 的核数
int max = Runtime.getRuntime().availableProcessors();
ExecutorService service =new ThreadPoolExecutor(
2,
max,
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()
);
-
I/O密集型：
在程序中有15个大型任务，io十分占用资源；I/O 密集型就是判断我们程序中十分耗 I/O 的线程数量，大约是最大 I/O 数的一倍到两倍之间。
十二 四大函数式接口
新时代程序员：lambda 表达式、链式编程、函数式接口、Stream 流式计算
函数式接口：只有一个方法的接口
12.1 Function 函数型接口
package com.sjmp.demo12Function;
import java.util.function.Function;
/**
* @author: sjmp1573
* @date: 2020/12/1 20:09
* @description:
*/
public class FunctionDemo {
public static void main(String[] args) {
Function<String,String> function = (str)->{
return str;
};
System.out.println(function.apply("aaaaaaa"));
}
}
12.2 Predicate 断定型接口
package com.sjmp.demo12Function;
import java.util.function.Predicate;
/**
* @author: sjmp1573
* @date: 2020/12/1 20:14
* @description:
*/
public class PredicateDemo {
public static void main(String[] args) {
Predicate<String> predicate = (str)->{
return str.isEmpty();
};
System.out.println(predicate.test("aaa"));
System.out.println(predicate.test(""));
}
}
12.3 Suppier 供给型接口
package com.sjmp.demo12Function;
import java.util.function.Supplier;
/**
* @author: sjmp1573
* @date: 2020/12/1 20:17
* @description:
*/
public class SupplierDemo {
public static void main(String[] args) {
Supplier<String> supplier = ()->{
return "1024";
};
System.out.println(supplier.get());
}
}
12.4 Consummer 消费型接口
package com.sjmp.demo12Function;
/**
* @author: sjmp1573
* @date: 2020/12/1 20:19
* @description:
*/
public class Consumer {
public static void main(String[] args) {
java.util.function.Consumer<String> consumer = (str)->{
System.out.println(str);
};
consumer.accept("abc");
}
}
十三 Stream流式计算
package com.sjmp.demo13Stream;
import java.util.Arrays;
import java.util.List;
/**
* @author: sjmp1573
* @date: 2020/12/1 20:25
* @description:
*/
public class StreamDemo {
public static void main(String[] args) {
User user1 = new User(1, "a", 21);
User user2 = new User(2, "b", 22);
User user3 = new User(3, "c", 23);
User user4 = new User(4, "d", 24);
User user5 = new User(5, "e", 25);
List<User> list = Arrays.asList(user1, user2, user3, user4, user5);
// lambda、链式编程、函数式接口、流式计算
list.stream()
.filter(user -> {return user.getId()%2 == 0;})
.filter(user -> {return user.getAge()>23;})
.map(user -> {return user.getName().toUpperCase();})
.sorted((u1,u2)->{return u2.compareTo(u1);})
.limit(1)
.forEach(System.out::println);
}
}
14 ForkJoin
ForkJoin 在JDK1.7，并行执行任务！提高效率~。在大数据量速率会更快！
大数据中：MapReduce 核心思想->把大任务拆分为小任务！
14.1 ForkJoin 特点：工作窃取！
实现原理：双端队列！从上面和下面都可以去拿到任务进行执行！
14.2 如何使用ForkJoin？
-
通过 ForkJoinPool 来执行
-
计算任务 execute（ForkJoinTask task）
-
计算类要去继承 ForkJoinTask；
ForkJoin 的计算类
package com.sjmp.demo14ForkJoin;
import sun.dc.pr.PRError;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;
/**
* @author: sjmp1573
* @date: 2020/12/1 21:06
* @description:
*/
public class ForkJoinTest {
private static final long SUM = 20_0000_0000;
public static void main(String[] args) throws ExecutionException, InterruptedException {
test1();
test2();
test3();
}
/*
* 使用普通方法
*
* */
public static void test1(){
long star = System.currentTimeMillis();
long sum = 0L;
for (int i = 0; i < SUM; i++) {
sum+=i;
}
long end = System.currentTimeMillis();
System.out.println(sum);
System.out.println("时间：" + (end-star));
System.out.println("---------------");
}
/*
*
* 使用 ForkJoin 方法
* */
public static void test2() throws ExecutionException, InterruptedException {
long star = System.currentTimeMillis();
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinDemo(0L,SUM);
ForkJoinTask<Long> submit = forkJoinPool.submit(task);
Long along = submit.get();
System.out.println(along);
long end = System.currentTimeMillis();
System.out.println("时间：" + (end - star));
System.out.println("---------------");
}
/*
* 使用流计算
* */
public static void test3(){
long star = System.currentTimeMillis();
long sum = LongStream.range(0L,20_0000_0000L).parallel().reduce(0,Long::sum);
System.out.println(sum);
long end = System.currentTimeMillis();
System.out.println("时间：" + (end - star));
System.out.println("-------------");
}
}
1999999999000000000
时间：719
---------------
1999999999000000000
时间：8573
---------------
1999999999000000000
时间：208
-------------
Process finished with exit code 0
.parallel().reduce(0, Long::sum)使用一个并行流去计算整个计算，提高效率。
十五 异步回调
Future 设计的初衷：对将来的某个事件结果进行建模！
其实就是前端 --> 发送ajax异步请求给后端
但是我们平时都使用CompletableFuture .
15.1 没有返回值的runAsync异步回调
package com.sjmp.demo15Async;
import java.sql.Time;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/12/1 21:29
* @description:
*/
public class CompletableFutureDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 发起一个请求
System.out.println(System.currentTimeMillis());
System.out.println("-----------");
CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
// 发起一个异步任务
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"......");
});
System.out.println(System.currentTimeMillis());
System.out.println("-------------------------");
System.out.println(future.get());//获取执行结果
}
}
15.2 有返回值的异步回调supplyAsync
package com.sjmp.demo15Async;
import org.junit.Test;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/12/1 21:29
* @description:
*/
public class CompletableFutureDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 发起一个请求
System.out.println(System.currentTimeMillis());
System.out.println("-----------");
CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
// 发起一个异步任务
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"......");
});
System.out.println(System.currentTimeMillis());
System.out.println("-------------------------");
System.out.println(future.get());//获取执行结果
}
@Test
public void test02() throws ExecutionException, InterruptedException {
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
System.out.println(Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 1024;
});
System.out.println(completableFuture.whenComplete((t,u)->{
// success 回调
System.out.println("t=>" +t);//正常的返回结果
System.out.println("u=>" +u);//抛出异常的错误信息
}).exceptionally((e)->{
// error 回调
System.out.println(e.getMessage());
return 404;
}).get());
}
}
whenComplete: 有两个参数，一个是t 一个是u
T：是代表的 正常返回的结果；
U：是代表的 抛出异常的错误信息；
如果发生了异常，get可以获取到exceptionally返回的值；
十六 JMM
16.1 对 Voatile 的理解
Volatile 是 Java 虚拟机提供 轻量级的同步机制
1、保证可见性
2、不保证原子性
3、禁止指令重排
如何实现可见性
volatile 变量修饰的共享变量在进行写操作的时候回多出一行汇编：
0x01a3de1d:movb $0×0，0×1104800（%esi）;0x01a3de24**:lock** addl $0×0,(%esp);
Lock前缀的指令在多核处理器下会引发两件事情。
1）将当前处理器缓存行的数据写回到系统内存。
2）这个写回内存的操作会使其他cpu里缓存了该内存地址的数据无效。
多处理器总线嗅探：
为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存后再进行操作，但操作不知道何时会写到内存。如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己的缓存值是不是过期了，如果处理器发现自己缓存行对应的内存地址呗修改，就会将当前处理器的缓存行设置无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据库读到处理器缓存中。
16.2 什么是 JMM ？
JMM: JAVA 内存模型，不存在的东西，是一个概念，也是一个约定！
关于JMM的一些同步的约定：
1、线程解锁前，必须把共享变量立刻刷回主存；
2、线程加锁前，必须读取主存中的最新值到工作内存中；
3、加锁和解锁是同一把锁；
线程中分为 工作内存、主内存
8种操作:
- Read（读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；
- load（载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中；
- Use（使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令；
- assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中；
- store（存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用；
- write（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中；
- lock（锁定）：作用于主内存的变量，把一个变量标识为线程独占状态；
- unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；
JMM对这8种操作给了相应的规定：
- 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
- 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
- 不允许一个线程将没有assign的数据从工作内存同步回主内存
- 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前，必须经过assign和load操作
- 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
- 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
- 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
- 对一个变量进行unlock操作之前，必须把此变量同步回主内存
遇到问题：程序不知道主存中的值已经被修改过了！；
十七 volitile
17.1保证可见性
package com.sjmp.demo17volatile;
import java.util.concurrent.TimeUnit;
/**
* @author: sjmp1573
* @date: 2020/12/1 21:59
* @description:
*/
public class VolatileDemo {
// 如果不加 volatile 程序会死循环
// 加了volatile 是可以保证可见性的
private volatile static Integer number = 0;
public static void main(String[] args) {
// main 线程
// 子线程1
new Thread(()->{
while (number==0){}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 子线程2
new Thread(()->{
while (number==0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
number = 1;
System.out.println(number);
}
}
17.2 不保证原子性
原子性：不可分割；
线程A在执行任务的时候，不能被打扰的，也不能被分割的，要么同时成功，要么同时失败。
package com.sjmp.demo17volatile;
/**
* @author: sjmp1573
* @date: 2020/12/2 19:35
* @description:
*/
public class VDemo02 {
private static volatile int number = 0;
public static void add(){
number++;
// ++ 不是一个原子操作，是2~3个操作
}
public static void main(String[] args) {
// 理论上 number === 20000
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 1; j <= 1000 ; j++) {
add();
}
}).start();
}
while(Thread.activeCount()>2){
// main gc
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+",num + "+number);
}
}
/*
* main,num + 19412
* */
使用原子类
package com.sjmp.demo17volatile;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author: sjmp1573
* @date: 2020/12/2 19:35
* @description:
*/
public class VDemo02 {
// private static volatile int number = 0;
private static volatile AtomicInteger number = new AtomicInteger();
public static void add(){
// number++;
// ++ 不是一个原子操作，是2~3个操作
number.incrementAndGet();//底层是 CAS 保证原子性
}
public static void main(String[] args) {
// 理论上 number === 20000
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 1; j <= 1000 ; j++) {
add();
}
}).start();
}
while(Thread.activeCount()>2){
// main gc
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+",num + "+number);
}
}
/*
* main,num + 19412
* main,num + 20000
* */
这些类的底层都直接和操作系统挂钩！是在内存中修改值。
Unsafe 类是一个很特殊的存在；
原子类为什么这么高级？
17.3 禁止指令重排
什么是指令重排？
我们写的程序，计算机并不是按照我们自己写的那样去执行的
源代码–>编译器优化重排–>指令并行也可能会重排–>内存系统也会重排–>执行
处理器在进行指令重排的时候，会考虑数据之间的依赖性！
int x=1; //1
int y=2; //2
x=x+5; //3
y=x*x; //4
//我们期望的执行顺序是 1_2_3_4 可能执行的顺序会变成2134 1324
//可不可能是 4123？ 不可能的
1234567
可能造成的影响结果：前提：a b x y这四个值 默认都是0
| 线程 A | 线程B |
|---|---|
| x = a | y = b |
| b = 1 | a = 2 |
正常的结果： x = 0; y =0;
| 线程A | 线程B |
|---|---|
| b=1 | a=2 |
| x=a | y=b |
可能在线程A中会出现，先执行b=1,然后再执行x=a；
在B线程中可能会出现，先执行a=2，然后执行y=b；
那么就有可能结果如下：x=2; y=1.
volatile可以避免指令重排：
volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序。
内存屏障：CPU指令。作用：
1、保证特定的操作的执行顺序；
2、可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现的可见性）
17.4 总结
- volatile 可以保证可见性
- 不能保证原子性
- 由于内存屏障，可以保证避免指令重排的现象产生
面试官：那么你知道在哪里用这个内存屏障用得最多呢？单例模式
十八 玩转单例模式
18.1 饿汉式
package com.sjmp.demo18Single;
/**
* @author: sjmp1573
* @date: 2020/12/2 19:56
* @description:
*/
public class SingleHungryDemo {
/*
* 可能会浪费空间
* */
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
private SingleHungryDemo(){
}
private final static SingleHungryDemo hungry = new SingleHungryDemo();
public static SingleHungryDemo getInstance(){
return hungry;
}
}
18.2 DCL 懒汉式
package com.sjmp.demo18Single;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
/**
* @author: sjmp1573
* @date: 2020/12/2 20:01
* @description:
*/
public class LazyMan {
private static boolean key = false;
private LazyMan(){
synchronized(LazyMan.class){
if (key == false){
key = true;
}else{
throw new RuntimeException("不要试图使用反射破坏异常");
}
}
System.out.println(Thread.currentThread().getName()+"ok");
}
private volatile static LazyMan lazyMan;
// 双重检测锁模式 简称 DCL 懒汉式
public static LazyMan getInstance(){
// 需要加锁
if (lazyMan == null){
lazyMan = new LazyMan();
/*
* 1.分配内存空间
* 2.执行构造方法，初始化对象
* 3.把这个对象指向这个空间
*
* 就有可能出现指令重排问题
* 比如执行的顺序是 1 3 2 等
* 我们就可以添加 volatile 保证指令重排问题
*
* */
}
return lazyMan;
}
// 单线程下是 ok 的
// 但是如果是并发的
public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// Java 中有反射
// LazyMan instance = LazyMan.getInstance();
Field key = LazyMan.class.getDeclaredField("key");
key.setAccessible(true);
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
LazyMan lazyMan1 = declaredConstructor.newInstance();
key.set(lazyMan1,false);
LazyMan instance = declaredConstructor.newInstance();
System.out.println(instance);
System.out.println(lazyMan1);
System.out.println(instance == lazyMan1);
}
}
18.3 静态内部类
//静态内部类
public class Holder {
private Holder(){
}
public static Holder getInstance(){
return InnerClass.holder;
}
public static class InnerClass{
private static final Holder holder = new Holder();
}
}
单例不安全, 因为反射
18.4 枚举
//enum 是什么？ enum本身就是一个Class 类
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumSingle instance1 = EnumSingle.INSTANCE;
Constructor declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
//java.lang.NoSuchMethodException: com.ogj.single.EnumSingle.()
EnumSingle instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}
}
使用枚举，我们就可以防止反射破坏了。
枚举类型的最终反编译源码：
public final class EnumSingle extends Enum
{
public static EnumSingle[] values()
{
return (EnumSingle[])$VALUES.clone();
}
public static EnumSingle valueOf(String name)
{
return (EnumSingle)Enum.valueOf(com/ogj/single/EnumSingle, name);
}
private EnumSingle(String s, int i)
{
super(s, i);
}
public EnumSingle getInstance()
{
return INSTANCE;
}
public static final EnumSingle INSTANCE;
private static final EnumSingle $VALUES[];
static
{
INSTANCE = new EnumSingle("INSTANCE", 0);
$VALUES = (new EnumSingle[] {
INSTANCE
});
}
}
十九 深入理解CAS
19.1 什么是CAS？
大厂必须深入研究底层！！！！修内功！操作系统、计算机网络原理、组成原理、数据结构
package com.sjmp.demo19CAS;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author: sjmp1573
* @date: 2020/12/2 20:21
* @description:
*/
public class casDemo {
// CAS: compareAndSet 比较并交换
public static void main(String[] args){
AtomicInteger atomicInteger = new AtomicInteger(2020);
// boolean compareAndSet(int expect, int update)
// 期望值、更新值
// 如果实际值 和 我期望值相同，那么就更新
// 如果实际制 和 我期望值不同，那么就不更新
System.out.println(atomicInteger.compareAndSet(2020,2021));
System.out.println(atomicInteger.get());
// 因为期望值是 2020 ，实际值却变成了2021 所以会修改失败
// CAS 是 CPU 的并发原语
atomicInteger.getAndIncrement();//++操作
System.out.println(atomicInteger.compareAndSet(2020,2021));
System.out.println(atomicInteger.get());
}
}
Unsafe 类
19.2 总结
CAS：比较当前工作内存中的值 和 主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环，使用的是自旋锁。
缺点：
- 循环会耗时；
- 一次性只能保证一个共享变量的原子性；
- 它会存在ABA问题
CAS：ABA问题？(狸猫换太子)
线程1：期望值是1，要变成2；
线程2：两个操作：
- 1、期望值是1，变成3
- 2、期望是3，变成1
所以对于线程1来说，A的值还是1，所以就出现了问题，骗过了线程1；
public class casDemo {
//CAS : compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
//boolean compareAndSet(int expect, int update)
//期望值、更新值
//如果实际值 和 我的期望值相同，那么就更新
//如果实际值 和 我的期望值不同，那么就不更新
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
//因为期望值是2020 实际值却变成了2021 所以会修改失败
//CAS 是CPU的并发原语
// atomicInteger.getAndIncrement(); //++操作
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
}
}
20. 原子引用
解决 ABA 问题，对应的思想：就是使用了乐观锁
带版本号的原子操作！
Integer 使用了对象缓存机制，默认范围是 -128~127，推荐使用静态工厂方法 valueOf 获取对象实例，而不是 new ，因为 valueOf 使用了缓存，而 new 一定会创建新的对象分配新的内存空间。
package com.marchsoft.lockdemo;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
/**
* Description：
*
* @author jiaoqianjin
* Date: 2020/8/12 22:07
**/
public class CASDemo {
/**AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
* 正常在业务操作，这里面比较的都是一个个对象
*/
static AtomicStampedReference atomicStampedReference = new
AtomicStampedReference<>(1, 1);
// CAS compareAndSet : 比较并交换！
public static void main(String[] args) {
new Thread(() -> {
int stamp = atomicStampedReference.getStamp(); // 获得版本号
System.out.println("a1=>" + stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 修改操作时，版本号更新 + 1
atomicStampedReference.compareAndSet(1, 2,
atomicStampedReference.getStamp(),
atomicStampedReference.getStamp() + 1);
System.out.println("a2=>" + atomicStampedReference.getStamp());
// 重新把值改回去， 版本号更新 + 1
System.out.println(atomicStampedReference.compareAndSet(2, 1,
atomicStampedReference.getStamp(),
atomicStampedReference.getStamp() + 1));
System.out.println("a3=>" + atomicStampedReference.getStamp());
}, "a").start();
// 乐观锁的原理相同！
new Thread(() -> {
int stamp = atomicStampedReference.getStamp(); // 获得版本号
System.out.println("b1=>" + stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1, 3,
stamp, stamp + 1));
System.out.println("b2=>" + atomicStampedReference.getStamp());
}, "b").start();
}
}
二十一 各种锁的理解
21.1 公平锁，非公平锁
- 公平锁：非常公平，不能插队，必须先来后到
/**
* Creates an instance of {@code ReentrantLock}.
* This is equivalent to using {@code ReentrantLock(false)}.
*/
public ReentrantLock() {
sync = new NonfairSync();
}
- 非公平锁：非常不公平，允许插队，可以改变顺序
/**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
21.2 可重入锁
- Synchronized 锁
package com.sjmp.demo21Lock;
/**
* @author: sjmp1573
* @date: 2020/12/2 20:45
* @description:
*/
public class SynchronizedDemo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sms();
},"A").start();
new Thread(()->{
phone.sms();
},"B").start();
}
}
class Phone{
public synchronized void sms(){
System.out.println(Thread.currentThread().getName()+"=> sms");
call();// 这里也有一把锁
}
public synchronized void call(){
System.out.println(Thread.currentThread().getName()+"=> call");
}
}
- Lock 锁
package com.sjmp.demo21Lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author: sjmp1573
* @date: 2020/12/2 20:49
* @description:
*/
public class LockDemo {
public static void main(String[] args) {
Phone2 phone2 = new Phone2();
new Thread(()->{
phone2.sms();
}).start();
new Thread(()->{
phone2.sms();
}).start();
}
}
class Phone2{
Lock lock = new ReentrantLock();
public void sms(){
lock.lock();//细节：这个两把锁，两个钥匙
// lock 锁必须配对，否则就是死锁在里面
try {
System.out.println(Thread.currentThread().getName()+"=>sms");
call();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void call(){
try {
lock.lock();
System.out.println(Thread.currentThread().getName()+"=>call");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
21.3 自旋锁
1.spinlock
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
2.自我设计自旋锁
public class SpinlockDemo {
// 默认
// int 0
//thread null
AtomicReference<Thread> atomicReference=new AtomicReference<>();
//加锁
public void myLock(){
Thread thread = Thread.currentThread();
System.out.println(thread.getName()+"===> mylock");
//自旋锁
while (!atomicReference.compareAndSet(null,thread)){
System.out.println(Thread.currentThread().getName()+" ==> 自旋中~");
}
}
//解锁
public void myUnlock(){
Thread thread=Thread.currentThread();
System.out.println(thread.getName()+"===> myUnlock");
atomicReference.compareAndSet(thread,null);
}
}
public class TestSpinLock {
public static void main(String[] args) throws InterruptedException {
ReentrantLock reentrantLock = new ReentrantLock();
reentrantLock.lock();
reentrantLock.unlock();
//使用CAS实现自旋锁
SpinlockDemo spinlockDemo=new SpinlockDemo();
new Thread(()->{
spinlockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
e.printStackTrace();
} finally {
spinlockDemo.myUnlock();
}
},"t1").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
spinlockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
e.printStackTrace();
} finally {
spinlockDemo.myUnlock();
}
},"t2").start();
}
}
运行结果：
t2 进程必须等待 t1 进程 Unlock 后，才能 Unlock ，在这之前进行自选等待.
21.4 死锁
package com.ogj.lock;
import java.util.concurrent.TimeUnit;
public class DeadLock {
public static void main(String[] args) {
String lockA= "lockA";
String lockB= "lockB";
new Thread(new MyThread(lockA,lockB),"t1").start();
new Thread(new MyThread(lockB,lockA),"t2").start();
}
}
class MyThread implements Runnable{
private String lockA;
private String lockB;
public MyThread(String lockA, String lockB) {
this.lockA = lockA;
this.lockB = lockB;
}
@Override
public void run() {
synchronized (lockA){
System.out.println(Thread.currentThread().getName()+" lock"+lockA+"===>get"+lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB){
System.out.println(Thread.currentThread().getName()+" lock"+lockB+"===>get"+lockA);
}
}
}
}
如何解开死锁
-
使用 jps 定位进程号，jdk 目录 bin 下 ：有一个 jps
命令：
jps -l
-
使用
jstack进程进程号找到死锁信息
一般情况信息在最后：
