Juc全网最全学习笔记【遇见狂神说】
B 站学习视频遇见狂神说《JUC并发编程最新版通俗易懂》
1、什么是JUC
源码 + 官方文档 面试高频问！
java.util工具包、包、分类- 业务：普通的线程代码 Thread
- Runnable 没有返回值、效率相比入 Callable 相对较低！
2、线程和进程
线程、进程
-
进程：一个程序，QQ.exe Music.exe 程序的集合；一个进程往往可以包含多个线程，至少包含一个！
- Java默认有
2个线程，main和gc垃圾回收
- Java默认有
-
线程：开了一个进程 Typora，写字，自动保存（线程负责的）
-
对于Java而言：Thread、Runnable、Callable
Java无法开启线程
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 */
}
}
}
//这是一个C++底层，Java是没有权限操作底层硬件的
private native void start0();
并发、并行
并发（多线程操作同一个资源）
- CPU 一核 ，模拟出来多条线程，天下武功，唯快不破，快速交替并行（多个人一起行走）
并行：多个人一起走
- CPU多核，多个线程可以同时执行，线程池
public class Test1{
public static void main(String[] args){
//获取CPU的核数
//CPU密集型，IO密集型
System.out.println(Runtime.getRuntime().availableProcessors());
}
}
并发编程的本质：充分利用CPU的资源
线程有几个状态
public enum State {
//运行
NEW,
//运行
RUNNABLE,
//阻塞
BLOCKED,
//等待
WAITING,
//超时等待
TIMED_WAITING,
//终止
TERMINATED;
}
wait/sleep 区别
1、 来自不同的类
wait => Object
sleep => Thread
一般企业中使用的休眠是：
TimeUnit.DAYS.sleep(1);//休眠一天
TimeUnit.SECONDS.sleep(1);//休眠1s
2、 关于锁的释放
wait 会释放锁
sleep 睡觉了，不会释放！
3、 使用的范围是不同的
wait必须使用在代码块中
.
sleep 可以再任何地方睡
4、是否需要捕获异常
wait 不需要捕获异常
sleep 必须要捕获异常
3、Lock锁（重点）
传统 Synchronized
/**
* 真正的多线程开发
* 线程就是一个单独的资源类，没有任何的附属操作！
*/
public class SaleTicketDemo01 {
public static void main(String[] args) {
//多线程操作
//并发：多线程操作同一个资源类，把资源类丢入线程
Ticket ticket = new Ticket();
//@FunctionalInterface 函数式接口 jdk1.8之后 lambda表达式
new Thread(()->{
for(int i=0;i<40;i++){
ticket.sale();
}
},"A").start();
new Thread(()->{
for(int i=0;i<40;i++){
ticket.sale();
}
},"B").start();
new Thread(()->{
for(int i=0;i<40;i++){
ticket.sale();
}
},"C").start();
}
}
//资源类
//属性+方法
//oop
class Ticket{
private int number=50;
//卖票的方式
// synchronized 本质：队列，锁
public synchronized void sale(){
if(number>0){
System.out.println(Thread.currentThread().getName()+" 卖出了第"+number+" 张票,剩余："+number+" 张票");
number--;
}
}
}
Lock 接口
公平锁：十分公平：可以先来后到
非公平锁：十分不公平：可以插队 （默认为非公平锁）
Synchronized 和 Lock 区别
- Synchronized 内置的Java关键字， Lock 是一个Java类
- Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁
- Synchronized 会自动释放锁，lock 必须要手动释放锁！如果不释放锁，死锁
- Synchronized 线程 1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；
- Synchronized 可重入锁，不可以中断的，非公平；Lock ，可重入锁，可以 判断锁，非公平（可以自己设置）；
- Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！
锁是什么，如何判断锁的是谁！
4、生产者和消费者问题
面试的：单例模式、排序算法、生产者和消费者、死锁
生产者和消费者问题 Synchronized 版
public class A {
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 number = 0;
//+1
public synchronized void increment() throws InterruptedException {
if(number!=0){
//等待操作
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我+1完毕了
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
if(number==0){
//等待操作
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程 我-1完毕了
this.notifyAll();
}
}
问题存在，A B C D 4 个线程！ 虚假唤醒
解决方案：if 改为 while 判断
/**
* 判断等待，业务，通知
*/
class Data2{//资源类 数字
private int number = 0;
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//condition.await();//等待
//condition.signalAll();//唤醒全部
//+1
public void increment() throws InterruptedException {
try {
lock.lock();
//业务代码
while (number !=0){
//等待操作
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程，我+1完毕了
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
//-1
public void decrement() throws InterruptedException {
try {
lock.lock();
//业务代码
while (number == 0){
//等待操作
condition.await();
}
number --;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程，我-1完毕了
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
JUC版的生产者和消费者问题
通过Lock 找到 Condition
代码实现：
/**
* 判断等待，业务，通知
*/
class Data2{//资源类 数字
private int number = 0;
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//condition.await();//等待
//condition.signalAll();//唤醒全部
//+1
public void increment() throws InterruptedException {
try {
lock.lock();
//业务代码
while (number !=0){
//等待操作
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程，我+1完毕了
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
//-1
public void decrement() throws InterruptedException {
try {
lock.lock();
//业务代码
while (number == 0){
//等待操作
condition.await();
}
number --;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他线程，我-1完毕了
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
5、8锁现象
如何判断锁的是谁！
锁会锁住：对象、Class
深刻理解我们的锁：
问题一：标准情况下，两个线程先打印 发短信 还是 打电话
结果是：
那么问题来了，为什么是这种顺序来打印的，是按顺序执行的吗？答案显然是错误的！
问题二：我们让打短信延迟4s
现在结果是什么情况呢？
结果依然是：发短信 打电话！
原因： synchronized 锁的对象是方法的调用者！两个方法使用的是同一把锁，谁先拿到，谁先执行！
问题三：添加一个普通方法，结果先执行哪一个呢？
结果：先执行hello()在打印发短信！原因是hello()是一个普通方法，并不是同步方法，不受Synchronized锁的影响，如果把发短信里的TimeUnit.SECONDS.sleep(4)去掉，那么就会顺序执行，限制性发短信再执行hello()。原因方法sendSms()和hello()两者并不会产生影响，在sendSms()中加入延时时，在线程开始时，就会等待4s再执行，去掉之后，两个方法并不会有谁等待谁的关系，就会按照顺序进行执行！(个人理解)
问题四：如果使用两个对象，分别调用发短信 和 打电话 那么顺序是什么呢？
结果： 打电话 发短信。
原因： 在发短信中 延时了4s，再加上Synchronized锁的对象是方法的调用者，如果有两把锁，就会根据执行时间来决定打印顺序！
问题 5、6 如果在方法上加上
static变成静态方法！结果又该如何？
结果： 发短信 打电话
原因： 对于static静态方法来说，对于整个类Class来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态方法static使用了Synchronized锁定，那么这个Synchronized锁会锁住整个对象！不管多少个对象，对于静态的锁都只有一把锁，谁先拿到这个锁谁先执行！其他进程都需要等待！
问题七：如果把两个方法设置为一个静态方法、一个同步方法，结果又将如何？
结果： 打电话 发短信
原因： 因为一个锁的是Class类模板，一个锁的是对象的调用者，call()不需要等待发短信，直接运行！
问题八：一个静态方法、一个同步方法，使用两个对象进行分别调用，顺序是什么呢？
结果： 打电话 发短信
原因： 因为两个对象，一样的原因，两把锁锁的不是同一个东西，所以后面的第二个对象不需要等待第一个对象去执行！
6、集合类不安全
List不安全
//java.util.ConcurrentModificationException 并发修改异常
public class ListTest{
public static void main(String[] args){
List<String> list = new ArrayList<>();
for(int i = 1;i<=30;++i){
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
},String.valueOf(i)).start();
}
}
}
执行结果：
结果：ArrayList在并发情况下是不安全的！
解决方案：
- 切换成
Vector就是线程安全的！
public class ListTest{
public static void main(String[] args){
List<String> list = new Vector<>();
for(int i = 1;i<=30;++i){
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
},String.valueOf(i)).start();
}
}
}
- 使用
Collections.synchronizedList(new ArrayList<>());
public class ListTest{
public static void main(String[] args){
List<String> list = Collections.synchronizedList(new ArrayList<>());
for(int i = 1;i<=30;++i){
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
},String.valueOf(i)).start();
}
}
}
- 使用
JUC中的包：Listlist = new CopyOnWriteArrayList<>();
public class ListTest{
public static void main(String[] args){
List<String> list = new CopyOnWriteArrayList<>();
for(int i = 1;i<=30;++i){
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
},String.valueOf(i)).start();
}
}
}
CopyOnWriteArrayList：写入时复制！COW计算机程序设计领域的一种优化策略
多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）；在写入的时候避免覆盖，造成数据的问题！
CopyOnWriteArrayList 比 Vector 厉害在哪里？
Vector的addElement()方法使用的是Synchronized，一般使用Synchronized效率较低
CopyOnWriteArrayList的add方法使用的是lock锁
Set不安全
和List属于同级，由于List在并发情况下不安全，则Set也是不安全的
解决方案：
- 使用
Collections工具类的synchronized包装的Set类 - 使用
CopyOnWriteArraySet写入复制的JUC解决方案
//java.util.ConcurrentModificationException
public class SetTest {
public static void main(String[] args) {
Set<String> set1 = new HashSet<>();
//Set set = Collections.synchronizedSet(new HashSet<>());
Set<String> set = new CopyOnWriteArraySet<>();
for (int i = 1; i <= 100; i++) {
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
HashSet底层是什么？
通过底层来看，HashSet的底层其实就是一个HashMap
public HashSet() {
map = new HashMap<>();
}
//add 本质其实就是一个map的key，map的key是无法重复的，所以使用的就是map存储
//hashSet就是使用了hashmap key不能重复的原理
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
//PRESENT是什么？ 是一个常量 不会改变的常量 无用的占位
private static final Object PRESENT = new Object();
Map不安全
//map是这样用的吗？ 不是，工作中不使用HashMap
//默认等价于什么？ new HashMap<>(16,0.75);
//Map<String, String> map = new HashMap<>();
HashMap默认加载因子是0.75，默认的初始容量是16
同样的HashMap基础类也存在并发修改异常！
public class HashMapTest {
public static void main(String[] args) {
//map是这样用的吗？ 不是，工作中不使用HashMap
//默认等价于什么？ new HashMap<>(16,0.75);
//Map map = new HashMap<>();
// Collections.synchronizedMap()
Map<String, String> map = new ConcurrentHashMap<>();
for (int i = 1; i <= 30; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}
解决方案：
- 使用
Collections.synchronizedMap(new HashMap<>());处理 - 使用
new ConcurrentHashMap<>()进行并发处理
7、Callable(简单)
- 可以有返回值
- 可以抛出异常
- 方法不同
run()/call()
代码测试
public class CallableTest{
public static void main(String[] args){
for(int i = 1;i<10;++i){
new Thread(new MyThread()).start;
}
}
}
class MyThread implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName());
}
}
使用Callable进行多线程操作：
Callable泛型T就是Call运行方法的返回值类型
Callable如何放入到Thread里面呢？
对于Thread运行，只能传入Runnable类型的参数
FutureTask中可以接受Callable参数
这样我们就可以先把Callable放入FutureTask中，如何再把FutureTask放入到Thread就可以了！
public class CallableTest {
public static void main(String[] args)throws Exception {
//new Thread(new Runnable()).start();
//new Thread(new FutuerTask()).start
//构造器
//new Thread(new FutuerTask( Callable )).start
for (int i = 1; i <= 10; i++) {
MyThread thread = new MyThread();
//适配类：FutureTask
FutureTask<String> futureTask = new FutureTask<>(thread);
//放入Thread使用
new Thread(futureTask,String.valueOf(i)).start();
//获取返回值
String s = futureTask.get();
System.out.println("返回值"+s);
}
}
}
class MyThread implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("Call:"+Thread.currentThread().getName());
return "String"+Thread.currentThread().getName();
}
}
这样我们就可以使用Callable来进行多线程编程了。并且我们发现可以有返回值 了，并且可以抛出异常
8、常用的辅助类（必须会！）
8.1 CountDownLatch
其实就是一个减法计数器，对于计数器归零之后在进行后面的操作，这是一个计数器
//计数器
public class CountDownLatchDemo {
public static void main(String[] args) {
//总数是6 必须要执行的任何的时候，再使用！
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 1; i <= 6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"走了");
countDownLatch.countDown();// 数量-1
},String.valueOf(i)).start();
}
try {
countDownLatch.await();//等待计数器归 0 ，然后再向下执行
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("关门");
}
}
主要方法：
countDown减一操作await等待计数器归零
await等待计数器为0，就唤醒，再继续向下执行。
8.2 CyclickBarrier
其实就是一个加法计数器
public class CyclicBarrierDemo {
public static void main(String[] args) {
/*
*集齐七颗龙珠召唤神龙
* */
CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
System.out.println("召唤神龙成功！");
});
for (int i = 1; i <= 7 ; i++) {
final int temp = i;
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"收集了"+temp+"颗龙珠");
try {
cyclicBarrier.await();//等待
} catch(Exception e){
e.printStackTrace();
}
}).start();
}
}
}
8.3 Semaphore
Semaphore：信号量
代码模拟抢车位
public class SemaphoreDemo {
public static void main(String[] args) {
/**
* 参数：线程数量 应用场景：限流！
*/
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 3; 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 {
//release() 释放
semaphore.release();//释放
}
},String.valueOf(i)).start();
}
}
}
原理：
semaphore.acquire()获取资源，如果资源已经使用完了，就等待资源释放后再进行使用！
semaphore.release()释放，会将当前的信号量释放+1，然后唤醒等待的线程！
应用场景：
- 多个共享资源互斥的使用
- 并发限流，控制最大的线程数
9、阻塞队列
BlockingQueue
什么情况下会使用阻塞队列？
- 多线程并发处理
线程A调用线程B，则A必须等待线程B执行完之后才能执行 - 线程池
学会使用队列
| 方式 | 抛出异常 | 不会抛出异常，有返回值 | 阻塞 等待 | 超时等待 |
|---|---|---|---|---|
| 添加 | add() | offer() | put() | offer(,) |
| 移除 | remove() | poll() | take() | poll(,) |
| 检测队首元素 | element() | peek() | - | - |
/**
* 抛出异常
*/
public static void test1(){
//参数：队列的大小
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
// java.lang.IllegalStateException: Queue full 队列满
System.out.println(blockingQueue.add("a"));
System.out.println(blockingQueue.add("b"));
System.out.println(blockingQueue.add("c"));
System.out.println("========================");
// java.util.NoSuchElementException
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
}
/**
* 不抛出异常
*/
public static void test2(){
//队列的大小
ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);
//
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
//System.out.println(blockingQueue.offer("d"));//false 不抛出异常！
System.out.println("-=======================");
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());//null 不抛出异常！
}
/*
* 等待，阻塞（一直阻塞）
* */
public static void test3() throws InterruptedException {
ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);
blockingQueue.put("a");
blockingQueue.put("b");
blockingQueue.put("c");
//blockingQueue.put("d");//队列没有位置了，一直阻塞
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
//System.out.println(blockingQueue.take()); 没有这个元素，一直等待
}
/*
* 等待，阻塞（等待超时）
* */
public static void test4() throws InterruptedException {
ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
//System.out.println(blockingQueue.offer("d", 3, TimeUnit.SECONDS));//超时2秒
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));
}
SynchronousQueue 同步队列
/**
* 同步队列
* 和其他的BlockingQueue 不一样，SynchronousQueue 不存储元素
* put了一个元素，必须从里面先take取出来，否则不能在put进去值！
*/
public class SynchronousQueueTest {
public static void main(String[] args) {
SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();//同步队列
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+" put 1");
synchronousQueue.put("1");
System.out.println(Thread.currentThread().getName()+" put 2");
synchronousQueue.put("2");
System.out.println(Thread.currentThread().getName()+" put 3");
synchronousQueue.put("3");
} catch (Exception e) {
e.printStackTrace();
}
},"T1").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+ synchronousQueue.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+synchronousQueue.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+synchronousQueue.take());
} catch (Exception e) {
e.printStackTrace();
}
},"T2").start();
}
}
10、线程池（重点）
池化技术
程序的运行，本质：占用系统的资源！优化资源的使用！=> 池化技术
线程池、连接池、对象池、内存池///… 创建、销毁十分浪费资源
池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。
线程池的好处：
- 降低资源的消耗
- 提高响应的速度
- 方便管理
线程复用，可以控制最大并发数，管理线程
线程池：三大方法
/**
* @function Executors 工具类、3大方法
* @author 派 大 星
* @date 2022/3/31 22:49
*/
public class Demo01 {
public static void main(String[] args) {
// 单个线程
// ExecutorService threadPool = Executors.newSingleThreadExecutor();
// 创建一个固定的线程池的大小
// ExecutorService threadPool = Executors.newFixedThreadPool(5);
// 可伸缩的，遇强则强，遇弱则弱
ExecutorService threadPool = Executors.newCachedThreadPool();
try {
for (int i = 1; i <= 100; i++) {
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
}catch (Exception e){
e.printStackTrace();
}finally {
// 线程池用完，程序执行完关闭线程池
threadPool.shutdown();
}
}
}
7大参数
源码分析：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE ,// 约21亿 oom溢出
60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
}
// 本质：ThreadPoolExecutor()
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;
}
手动创建一个线程池
/**
* @author 派 大 星
* @function
* @date 2022/4/1 7:12
* 四种拒绝策略
*/
public class ThreadPoolExecutorDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
2,
5,
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy());
try {
for (int i = 1; i <= 9; i++) {
//使用自定义线程池创建线程
//最大承载：Deque + max(双端队列 + 最大线程池数)
threadPoolExecutor.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭线程
threadPoolExecutor.shutdown();
}
}
}
四种拒绝策略
/**
* new ThreadPoolExecutor.AbortPolicy() 银行满了，还有人进来，不处理这个人，抛出异常
* new ThreadPoolExecutor.CallerRunsPolicy() 哪来的去哪里！
* new ThreadPoolExecutor.DiscardPolicy() 队列满了，丢掉任务，不会抛出异常！
* new ThreadPoolExecutor.DiscardOldestPolicy() 队列满了。尝试去和最早的竞争（竞争成功，执行，竞争不成功，则丢掉任务），也不会抛出异常！
*/
小结和拓展
了解：IO密集型、CPU密集型
// 最大线程到底如何定义？
// 1. CPU 密集型 CPU几核，就是几，可以保持CPU的效率最高！Runtime.getRuntime().availableProcessors()
// 2. IO 密集型 > 判断你程序中十分消耗资IO的线程
// 程序 15个大型任务，io十分占用资源
11、四大函数式接口（必须掌握）
新时代程序员：lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口：只有一个方法的接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
//简化编程模型，在新版本框架底层大量应用
//foreach(消费者类型的函数式接口)
Function函数式接口
/**
* @author 派 大 星
* @function
* @date 2022/4/1 8:05
* Function 函数型接口，有一个输入参数，有一个输出
* 只要是函数型接口，可以用lambda表达式简化
*
*/
public class Demo01 {
public static void main(String[] args) {
// 工具类：输出输入的值
//
// Function function = new Function() {
// @Override
// public String apply(String s) {
// return s;
// }
// };
// lambda表达式简化
Function<String, String> function = (str)->{return str;};
System.out.println(function.apply("123"));
}
}
Predicate断定型接口：有一个输入参数，返回值只能是 布尔值！
/**
* @author 派 大 星
* @function
* @date 2022/4/1 19:42
* 断定性接口：有一个输入参数，返回值只能是 布尔值！
*/
public class Demo02 {
public static void main(String[] args) {
//判断字符串是否为空
// Predicate predicate = new Predicate() {
// @Override
// public boolean test(String s) {
// return s.isEmpty();
// }
// };
Predicate<String> predicate = (str)->{
return str.isEmpty();
};
System.out.println(predicate.test(""));
}
}
Consumer消费型接口
/**
* @author 派 大 星
* @function
* @date 2022/4/1 19:48
* Consumer 消费型接口：只有输入，没有返回值！
*/
public class Demo03 {
public static void main(String[] args) {
// Consumer consumer = new Consumer() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// };
Consumer<String> consumer =(str)->{
System.out.println(str);
};
consumer.accept("dadada");
}
}
Supplier供给型接口
/**
* @author 派 大 星
* @function
* @date 2022/4/1 19:52
* Supplier 消费型接口：没有参数，只有返回值！
*/
public class Demo04 {
public static void main(String[] args) {
// Supplier supplier = new Supplier() {
// @Override
// public String get() {
// return "null";
// }
// };
Supplier<String> supplier =()->{return "xxxx";};
System.out.println(supplier.get());
}
}
12、Stream流式计算
什么是Stream流式计算？
大数据：存储+计算
集合、Mysql 本质就是存储东西！
/**
* @author 派 大 星
* @function
* @date 2022/4/1 20:14
* 题目要求：一分钟内完成此题，只能用一行代码实现！
* 现有5个用户！筛选
* 1. ID必须是偶数
* 2. 年龄必须大于23
* 3. 用户名转为大写字母
* 4. 用户名字母倒着排序
* 5. 只输出一个用户
*/
public class Test {
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(6,"e",25);
List<User> users = Arrays.asList(user1, user2, user3, user4, user5);
//集合就是存储
users.stream()
// 过滤 filter(Predicate predicate);
.filter(u->{return u.getId()%2==0;})
.filter(u->{return u.getAge()>23;})
// map(Function mapper);
.map(u->{return u.getName().toUpperCase();})
//sorted(Comparator comparator);
.sorted((u1,u2)->{return u2.compareTo(u1);})
.limit(1)
.forEach(System.out::println);
}
}
13、ForkJoin
什么是ForkJoin
ForkJoin在JDK1.7 ，并行执行任务！提高效率，大数据量！
ForkJoin特点：工作窃取
这个里面维护的都是双端队列
如何理解工作窃取：现有两个线程A、B，假设B提前执行结束，但是B不能一直等待A执行结束，所以B会窃取A的任务进行执行
ForkJoin如何使用
/**
* @author 派 大 星
* @function
* @date 2022/4/1 21:04
* 求和计算任务
* 如何使用ForkJoin
* 1. ForkJoinPool 通过它来执行
* 2. 计算任务 ForkJoinPool.execute(ForkJoinTask task)
* 3. 计算类必须继承 ForkJOinTask
*/
public class ForkJoinDemo extends RecursiveTask<Long> {
private Long start;
private Long end;
//临界值
private Long temp = 10000L;
public ForkJoinDemo(Long start, Long end) {
this.start = start;
this.end = end;
}
public void test(){
}
//计算方法
@Override
protected Long compute() {
if (end-start < temp){
Long sum = 0L;
for (Long i = start; i <= end; i++) {
sum+=i;
}
return sum;
}else {//使用ForkJoin
//中间值
long middle = (start + end) / 2;
ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
//拆分任务，把任务压入线程队列
task1.fork();
ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
//拆分任务，把任务压入线程队列
task2.fork();
return task1.join() + task2.join();
}
}
}
测试：
/**
* @author 派 大 星
* @function
* @date 2022/4/1 21:35
*/
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
test3();
}
public static void test1(){
//3724
Long sum = 0L;
long start = System.currentTimeMillis();
for (int i = 1; i <= 10_0000_0000; i++) {
sum+=i;
}
long end = System.currentTimeMillis();
System.out.println("sum="+sum+"时间："+(end-start));
}
/**
* 使用ForkJoin调优的
* 3922
*/
public static void test2() throws ExecutionException, InterruptedException {
long start = System.currentTimeMillis();
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
//提交任务
ForkJoinTask<Long> submit = forkJoinPool.submit(task);
Long sum = submit.get();
long end = System.currentTimeMillis();
System.out.println("sum="+sum+"时间："+(end-start));
}
/**
* 185
*/
public static void test3(){
long start = System.currentTimeMillis();
//Stream并行流
long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
long end = System.currentTimeMillis();
System.out.println("sum="+sum+"时间："+(end-start));
}
}
14、异步回调
Future设计的初衷：对将来的某个事件的结果进行建模
/**
* @author 派 大 星
* @function
* @date 2022/4/1 22:42
*
* 异步调用：CompletableFuture
* 异步执行
* 成功回调
* 失败回调
*/
public class Demo01 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//没有返回值的 runAsync 异步回调
// CompletableFuture completableFuture = CompletableFuture.runAsync(()->{
// try {
// TimeUnit.SECONDS.sleep(2);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName()+"runAsync => Void");
// });
// System.out.println("111111");
// //阻塞获取执行结果
// completableFuture.get();
// 有返回值的 supplyAsync 异步回调
//ajax 成功和失败的回调
// 返回的是错误信息
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
System.out.println(Thread.currentThread().getName()+"supplyAsync => Integer");
int i = 10/0;
return 1024;
});
Integer integer = completableFuture.whenComplete((t, u) -> {
//t 为正常的返回结果
System.out.println("t=>" + t);
//u 为失败的返回结果
System.out.println("u=>" + u);
}).exceptionally((e) -> {
System.out.println(e.getMessage());
return 233;
}).get();
System.out.println(integer);
}
}
15、JMM
请你谈谈你对Volatile的理解
Volatile是Java虚拟机提供 的轻量级的同步机制
- 保证可见性
不保证原子性- 禁止指令重排
什么是JMM
JMM：Java内存模型，不存在的东西！
关于JMM的一些同步的约定：
- 线程解锁前，必须把共享变量
立刻刷回主存 - 线程加锁前，必须读取主存中的最新值到工作内存中！
- 加锁和解锁是同一把锁
线程：工作内存、主内存
内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）
-
lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
-
unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
-
read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
-
load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
-
use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
-
assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
-
store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
-
write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中
JMM对这八种指令的使用，制定了如下规则：
-
不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
-
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
-
不允许一个线程将没有assign的数据从工作内存同步回主内存
-
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
-
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
-
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
-
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
-
对一个变量进行unlock操作之前，必须把此变量同步回主内存
public class JmmDemo {
private static int num = 0;
public static void main(String[] args) {//main线程
// 线程1
new Thread(()->{
while (num == 0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
num = 1;
System.out.println(num);
}
}
问题：程序不知道主内存的值已经被修改过了
16、Volatile
1、保证可见性
public class JmmDemo {
/**
* 不加volatile 程序就会死循环
* 加volatile 可以保证可见性
*/
private volatile static int num = 0;
public static void main(String[] args) {//main线程
// 线程1 对主内存的变化是不知道的
new Thread(()->{
while (num == 0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
num = 1;
System.out.println(num);
}
}
2、不保证原子性
原子性：不可分割
public class VDemo02 {
/**
* volatile 不保证原子性
*/
private volatile static int num = 0;
public static void add(){
num++;
}
public static void main(String[] args) {
//理论上结果为20000
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount() > 2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+num);
}
}
如果不加lock 和 Synchronized ，怎么样保证原子性
原子类为什么这么高级
public class VDemo02 {
/**
* volatile 不保证原子性
*/
private static AtomicInteger num = new AtomicInteger();
public static void add(){
// AtomicInteger的+1操作
num.getAndIncrement();
}
public static void main(String[] args) {
//理论上结果为20000
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount() > 2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+num);
}
}
指令重排
什么是指令重排：你写的程序，计算机并不是按照你写的那样去执行的。
源代码 -> 编译器优化的重排 -> 指令并行也可能重排 -> 内存系统也会重排 --> 执行
处理器在进行指令重排的时候，考虑：数据之间的依赖性！
int x = 1; //1
int y = 4; //2
x = x + 4; //3
y = x * x; //4
我们所期望的：1234 但是可能执行的时候会变成 2134 1324
可不可能是 4123！
可能造成影响的结果：a b x y 这四个值默认都是 0
| 线程A | 线程B |
|---|---|
| x = a | y = b |
| b = 1 | a = 2 |
正常的结果 ：x = 0; y = 0；但是可能由于指令重排
| 线程A | 线程B |
|---|---|
| x = a | y = b |
| b = 1 | a = 2 |
指令重排导致的诡异结果：x = 2；y = 1;
Volatile可以避免指令重排：
内存屏障。CPU指令，作用：
- 保证特定的操作的执行顺序
- 可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）
Volatile是可以保持 可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！
17、彻底玩转单例模式
内存屏障在单例模式中使用的最多！
饿汉式
/**
* @author 派 大 星
* @function 饿汉式单例
* @date 2022/4/2 21:09
*/
public class Hungry {
/**
* 可能会浪费空间
*/
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 Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
}
DCL懒汉式
/**
* @author 派 大 星
* @function 懒汉式单例模式
* @date 2022/4/2 21:48
*/
public class LazyMan {
private LazyMan(){
synchronized (LazyMan.class){
if (lazyMan != null){
throw new RuntimeException("不要试图使用反射破坏异常");
}
}
System.out.println(Thread.currentThread().getName()+" ok");
}
private static LazyMan lazyMan;
/**
* 双重检测锁模式的 懒汉式单例 DCL懒汉式
*/
public static LazyMan getInstance(){
if (lazyMan == null){
synchronized (LazyMan.class){
if (lazyMan == null){
lazyMan = new LazyMan();
//不是一个原子性操作
}
}
}
return lazyMan;
}
//反射
public static void main(String[] args) throws Exception {
LazyMan instance = LazyMan.getInstance();
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor();
// 破除私有权限
declaredConstructor.setAccessible(true);
LazyMan instance2 = declaredConstructor.newInstance();
System.out.println(instance);
System.out.println(instance2);
}
}
/**
* 1. 分配内存空间
* 2. 执行构造方法，初始化对象
* 3. 把这个对象指向这个空间
*
* 123
* 132 A
* B 此时lazyMan还没有完成构造
*/
静态内部类
/**
* @author 派 大 星
* @function 静态内部类
* @date 2022/4/2 22:02
*/
public class Holder {
private Holder(){
}
public static Holder getInstance(){
return InnerClass.HOLDER;
}
public static class InnerClass{
private final static Holder HOLDER = new Holder();
}
}
单例不安全，反射
枚举
/**
* @author 派 大 星
* @function enum是一个什么？本身也是一个Class类
* @date 2022/4/2 22:11
*/
public enum EnumSingle {
INSTANCE;
public static EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws Exception {
EnumSingle instance = EnumSingle.INSTANCE;
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
// 破除私有权限
declaredConstructor.setAccessible(true);
EnumSingle enumSingle = declaredConstructor.newInstance();
System.out.println(enumSingle);
System.out.println(instance);
}
}
18、深入理解CAS
什么是CAS
public class CASDemo {
//CAS
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2022);
// 期望值 ，更新值
// public final boolean compareAndSet(int expect, int update)
// 如果我期望的值达到了，那么就更新，否则，就不更新 ,CAS 是CPU的并发原语
System.out.println(atomicInteger.compareAndSet(2022, 2023));
System.out.println(atomicInteger.get());
atomicInteger.getAndIncrement();
System.out.println(atomicInteger.compareAndSet(2022, 2023));
}
}
Unsafe类
CAS：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！
缺点：
- 循环会耗时
- 一次性只能保证一个共享变量的原子性
- ABA问题
CAS：ABA问题（狸猫换太子）
解释：现有A、B线程对资源A进行操作（操作同一资源），线程A中含有CAS操作，
当A = 1时，将1 修改为2 。线程B中同样含有CAS操作，当A = 1时，
将A替换成3,但是B的线程执行速度很快，在进行CAS操作时，将A修改为3后，又将3修改为了1，
此时线程A再进行CAS操作时，A的值虽然为1，但是A的值已经被修改过了！
public class CASDemo {
//CAS
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2022);
// 期望值 ，更新值
// public final boolean compareAndSet(int expect, int update)
// 如果我期望的值达到了，那么就更新，否则，就不更新 ,CAS 是CPU的并发原语
//=================捣乱的线程=====================
System.out.println(atomicInteger.compareAndSet(2022, 2023));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2023, 2022));
System.out.println(atomicInteger.get());
//=================期望的线程=====================
System.out.println(atomicInteger.compareAndSet(2022, 6666));
System.out.println(atomicInteger.get());
}
}
19、原子引用
解决ABA问题，引用原子引用！对应的思想（乐观锁）
带版本号的原子操作！
public class atomicReferenceDemo {
public static void main(String[] args) {
// AtomicStampedReference 注意：如果泛型是一个包装类，注意对象的引用问题
// 正常的业务操作，这里引用的都是一个个对象
AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<Integer>(1,1);
// CAS compareAndSet: 比较并交换！
// 乐观锁的原理一样！
new Thread(()->{
//获取版本号
int stamp = atomicStampedReference.getStamp();
System.out.println("a1 =>"+stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("a2 =>"+stamp);
System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("a3 =>"+stamp);
},"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, 6, stamp, stamp + 1));
System.out.println("b2 =>"+atomicStampedReference.getStamp());
},"b").start();
}
}
Integer使用了对象缓存机制，默认范围是 -128~127，推荐使用静态工厂方法valueOf获取对象的实例，而不是new ，因为valueOf使用缓存，而new 一定会创建新的对象分配新的内存空间！
20、各种锁的理解
1 公平锁、非公平锁
公平锁：非常公平，比如一个队列不能插队的，必须先来后到
非公平锁：非常不公平，可以插队（默认都是非公平锁）比如l两个任务耗时分别是3s、3h,不可能让3s一直等待3h的完成后再执行
public ReentrantLock() {
sync = new NonfairSync();
}
// 重载方法
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
2 可重入锁
可重入锁（递归锁）
Synchronized锁
public class Demo01 {
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锁
public class Demo02 {
public static void main(String[] args) {
Phone2 phone = new Phone2();
new Thread(()->{
phone.sms();
},"A").start();
new Thread(()->{
phone.sms();
},"B").start();
}
}
class Phone2{
Lock lock = new ReentrantLock();
public void sms(){
// 细节问题：lock.lock(); lock.lock(); Lock 锁必须配对，否则就会死在里面
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+"sms");
//这里也有一把锁
call();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void call(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+"call");
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
3 自旋锁
自定义自旋锁
public class SpinLockDemo {
/**
* int 0
* Thread null
*/
AtomicReference<Thread> atomicReference = new AtomicReference<>();
//加锁
public void myLock(){
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+" => myLock");
// 自旋锁
while (!atomicReference.compareAndSet(null,thread)){
}
}
//解锁
public void myUnLock(){
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+" =>myUnLock");
atomicReference.compareAndSet(thread,null);
}
public static void main(String[] args) {
// ReentrantLock reentrantLock = new ReentrantLock();
// reentrantLock.lock();
// reentrantLock.unlock();
SpinLockDemo spinLockDemo = new SpinLockDemo();
new Thread(()->{
spinLockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(3);
}catch (Exception e){
e.printStackTrace();
}finally {
spinLockDemo.myUnLock();
}
},"T1").start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
spinLockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(1);
}catch (Exception e){
e.printStackTrace();
}finally {
spinLockDemo.myUnLock();
}
},"T2").start();
}
}
4 死锁
死锁是什么？
死锁测试：怎么排除死锁
public class DeadLockDemo {
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+" => "+lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB){
System.out.println(Thread.currentThread().getName()+" lock:"+lockB+" => "+lockA);
}
}
}
}
解决问题
- 使用
jps -l定位进程号
- 使用
jstack 进程号找到死锁问题
面试或工作中排查问题
- 查看日志
- 查看堆栈信息