volatile
对 volatile的理解
volatile 是一种轻量级的同步机制。
jmm
jmm（java 内存模型）是一种抽象的概念，描述了一组规则或规范，定义了程序中各个变量的访问方式。
jvm运行程序的实体是线程，每个线程创建时 jvm 都会为其创建一个工作内存，是线程的私有数据区域。jmm中规定所有变量都存储在主内存，主内存是共享内存。线程对变量的操作在工作内存中进行，首先将变量从主内存拷贝到工作内存，操作完成后写会主内存。不同线程间无法访问对方的工作内存，线程通信（传值）通过主内存来完成。
jmm 对于同步的规定：
jmm 的三大特性
原子性是不可分割，某个线程正在做某个具体业务时，中间不可以被分割，要么全部成功，要么全部失败。
重排序：计算机在执行程序时，为了提高性能，编译器和处理器常常对指令做重排序，源代码经过编译器优化重排序、指令并行重排序、内存系统的重排序之后得到最终执行的指令。
在单线程中保证程序最终执行结果和代码执行顺序执行结果一致。
多线程中线程交替执行，由于重排序，两个线程中使用的变量能否保证一致性无法确定，结果无法确定。
处理器在处理重排序时需要考虑数据的依赖性。
volatile 实现禁止指令重排序，避免多线程环境下程序乱序执行。是通过内存屏障指令来执行的，通过插入内存屏障禁止在内存屏障后的指令执行重排序优化，并强制刷出缓存数据，保证线程能读取到这些数据的最新版本。
实例1：volatile 保证可见性
我要评论
class mydata {
//volatile int number = 0;//case2
//int number=0; //case1
public void change() {
number = 60;
}
}
public class volatiledemo {
public static void main(string[] args) {
mydata data=new mydata();
new thread(()->{
system.out.println(thread.currentthread().getname()+"\t come in");
try{ timeunit.seconds.sleep(3); } catch (interruptedexception e) {e.printstacktrace();}
data.change();
system.out.println(thread.currentthread().getname()+"\t updated number value:"+data.number);
},"a").start();
while(data.number==0){}
system.out.println(thread.currentthread().getname()+"\t over, get number:"+data.number);
}
}
当我们使用case1的时候，也就是number没有volatile修饰的时候，运行结果：
a come in
a updated number value:60
并且程序没有执行结束，说明在main线程中由于不能保证可见性，一直在死循环。
当执行case2的时候：
a come in
a updated number value:60
main over, get number:60
保证了可见性，因此main成功结束。
实例2： volatile 不保证原子性
class mydata {
volatile int number = 0;
public void change() {
number = 60;
}
public void addone() {
number++;
}
}
public class volatiledemo {
public static void main(string[] args) {
case2();
}
//验证原子性
public static void case2() {
mydata mydata = new mydata();
for (int i = 0; i < 20; i++) {
new thread(() -> {
for (int j = 0; j < 1000; j++) {
mydata.addone();
}
}, string.valueof(i)).start();
}
while(thread.activecount()>2){
thread.yield();
}
system.out.println(thread.currentthread().getname()+"\t number value:"+mydata.number);
}
}
最终输出结果可以发现并不是 20000，且多次输出结果并不一致，因此说明 volatile 不能保证原子性。
如何保证原子性
实例3：volatile 和 单例模式
dcl模式的单例模式
public class singleton {
private static singleton instance=null;
private singleton(){
system.out.println(thread.currentthread().getname()+" constructor");
}
//dcl 双端检锁机制
public static singleton getinstance(){
if(instance==null){
synchronized (singleton.class){
if(instance==null)
instance=new singleton();
}
}
return instance;
}
}
dcl 机制不能完全保证线程安全，因为有指令重排序的存在。
原因在于instance = new singleton(); 可以分为三步：
1. memory=allocate();//分配内存空间
2. instance(memory);//初始化对象
3. instance=memory;//设置instance指向分配的内存地址，分配成功后，instance!=null
由于步骤2和步骤3不存在数据依赖关系，且无论重排序与否执行结果在单线程中没有改变，因此这两个步骤的重排序是允许的。也就是说指令重排序只会保证单线程串行语义的一致性（as-if-serial），但是不会关心多线程间的语义一致性。
因此，重排序之后，先执行3会导致instance!=null，但是对象还未被初始化。此时，别的线程在调用时，获取了一个未初始化的对象。
因此，在声明 instance 时，使用 volatile 进行修饰，禁止指令重排序。
private static volatile singleton instance = null;
cas
cas 的全程是 compareandswap，是一条 cpu 并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更新为新的值，这个过程是原子的。
cas 的作用是比较当前工作内存中的值和主内存中的值，如果相同则执行操作，否则继续比较直到主内存和工作内存中的值一致为止。主内存值为v，工作内存中的预期值为a，要修改的更新值为b，当且仅当a和v相同，将v修改为b，否则什么都不做。
cas 底层原理：
在原子类中，cas 操作都是通过 unsafe 类来完成的。
//atomicinteger i++
public final int getandincrement(){
return unsafe.getandaddint(this,valueoffset,1);
}
其中 this 是当前对象， valueoffset 是一个 long ，代表地址的偏移量。
//atomicinteger.java
private static final unsafe unsfae=unsafe.getunsafe();//unsafe对象
private static final long valueoffset;//地址偏移量
static{
try{
valueoffset=unsafe.objectfieldoffset(atomicinteger.class.getdeclaredfield("value");
}catch(excepthion ex){throw new error(ex);}
}
private volatile int value;//存储的数值
unsafe 类是 rt.jar 下的 sun.misc 包下的一个类，基于该类可以直接操作特定内存的数据。
java方法无法直接访问底层系统，需要使用 native 方法访问，unsafe 类的内部方法都是 native 方法，其中的方法可以像c的指针一样直接操作内存，java 中的 cas 操作的执行都依赖于 unsafe 类的方法。
该变量表示变量值在内存中的偏移地址， unsafe 就是根据内存偏移地址获取数据的。
unsafe类
cas 并发源于体现在 java 中就是 unsafe 类的各个方法。调用该类中的 cas 方法，jvm会帮我们实现出 cas 汇编指令，这是一种完全依赖于硬件的功能。
原语是由若干条指令组成的，用于完成某个功能的过程。原语的执行必须是连续的，执行过程不允许被中断。所以 cas 是一条 cpu 的原子指令，不会造成数据不一致问题。
下边是 atomicinteger 中实现 i++ 功能所调用的 unsafe 类的函数。
//unsafe.getandaddint
public final int getandaddint(object var1,long var2,int var4){
int var5;
do{
//获取当前的值的地址
var5=this.getintvolatile(var1,var2);
//var1代表对象，var2和var5分别代表当前对象的真实值和期望值，如果二者相等，更新为var5+var4
}while(!this.compareandswapint(var1,var2,var5,var5+var4);
return var5;
}
在 getandaddint 函数中，var1 代表了 atomicinteger 对象， var2 代表了该对象在内存中的地址， var4 代表了期望增加的数值。
首先通过 var1 和 var2 获取到当前的主内存中真实的 int 值，也就是 var5。
然后通过循环来进行数据更改，当比较到真实值和对象的当前值相等，则更新，退出循环；否则再次获取当前的真实值，继续尝试，直到成功。
在 cas 中通过自旋而不是加锁来保证一致性，同时和加锁相比，提高了并发性。
具体情境来说：线程a和线程b并发执行 atomicinteger 的自增操作：
cas的缺点
aba问题
cas 实现一个重要前提需要取出内存中某个时刻的数据并在当下时刻比较并替换，这个时间差会导致数据的变化。
线程1从内存位置v中取出a，线程2也从v中取出a，然后线程2通过一些操作将a变成b，然后又把v位置的数据变成a，此时线程1进行cas操作发现v中仍然是a，操作成功。尽管线程1的cas操作成功，但是不代表这个过程没有问题。
这个问题类似于幻读问题，通过新增版本号的机制来解决。在这里可以使用 atomicstampedreference 来解决。
atomicstampedreference
通过 atomicstampedreference 来解决这个问题。
public class solveabademo {
static atomicstampedreference<integer> atomicstampedreference=new atomicstampedreference<>(100,1);
new thread(()->{
int stamp=atomicstampedreference.getstamp();
system.out.println(thread.currentthread().getname()+"\t 版本号："+stamp);
try {
thread.sleep(1000);
} catch (interruptedexception e) {
e.printstacktrace();
}
atomicstampedreference.compareandset(100,101,atomicstampedreference.getstamp(),atomicstampedreference.getstamp()+1);
system.out.println(thread.currentthread().getname()+"\t 版本号："+atomicstampedreference.getstamp());
atomicstampedreference.compareandset(101,100,atomicstampedreference.getstamp(),atomicstampedreference.getstamp()+1);
system.out.println(thread.currentthread().getname()+"\t 版本号："+atomicstampedreference.getstamp());
},"t1").start();
new thread(()->{
int stamp=atomicstampedreference.getstamp();
system.out.println(thread.currentthread().getname()+"\t 版本号："+stamp);
try {
thread.sleep(3000);
} catch (interruptedexception e) {
e.printstacktrace();
}
boolean ret=atomicstampedreference.compareandset(100,2019,stamp,stamp+1);
system.out.println(thread.currentthread().getname()+"\t"+ret
+" stamp:"+atomicstampedreference.getstamp()
+" value:"+atomicstampedreference.getreference());
},"t2").start();
}
}
t1 版本号：1
t2 版本号：1
t1 版本号：2
t1 版本号：3
t2 false stamp:3 value:100
集合类的线程安全问题
concurrentmodificationexception
这个异常也就是并发修改异常，java.util.concurrentmodificationexception。
导致这个异常的原因，是集合类本身是线程不安全的。
解决方案：
copyonwritearraylist
底层使用了private transient volatile object[] array;
copyonwritearraylist 采用了写时复制、读写分离的思想。
public boolean add(e e){
final reentrantlock lock=this.lock;
try{
//旧数组
object[] elements = getarray();
int len = elements.length;
//复制新数组
object[] newelements = arrays.copyof(elements, len+1);
//修改新数组
newelements[len] = e;
//更改旧数组引用指向新数组
setarray(newelements);
return true;
}finally{
lock.unlock();
}
}
添加元素时，不是直接添加到当前容器数组，而是复制到新的容器数组，向新的数组中添加元素，添加完之后将原容器引用指向新的容器。
这样做的好处是可以对该容器进行并发的读，而不需要加锁，因为读时容器不会添加任何元素。
copyonwritearrayset 本身就是使用 copyonwritearraylist 来实现的。
java锁
公平锁和非公平锁
reentrantlock 可以指定构造函数的 boolean 类型得到公平或非公平锁，默认是非公平锁，synchronized也是非公平锁。
公平锁是多个线程按照申请锁的顺序获取锁，是 fifo 的。并发环境中，每个线程在获取锁时先查看锁维护的等待队列，为空则战友，否则加入队列。
非公平锁是指多个线程不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。高并发情况下可能导致优先级反转或者饥饿现象。并发环境中，上来尝试占有锁，尝试失败，再加入等待队列。
可重入锁（递归锁）
可冲入锁指的是同一线程外层函数获取锁之后，内层递归函数自动获取锁。也就是线程能进入任何一个它已经拥有的锁所同步着的代码块。
reentrantlock 和 synchronized 都是可重入锁。
可重入锁最大的作用用来避免死锁。
自旋锁
自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式尝试获取锁。好处是减少线程上下文切换的消耗，缺点是循环时会消耗cpu资源。
实现自旋锁：
public class spinlockdemo {
//使用atomicreference<thread>来更新当前占用的 thread
atomicreference<thread> threadatomicreference=new atomicreference<>();
public static void main(string[] args) {
spinlockdemo demo=new spinlockdemo();
new thread(()->{
demo.mylock();
try {
thread.sleep(3000);
} catch (interruptedexception e) {
e.printstacktrace();
}
demo.myunlock();
},"t1").start();
try {
thread.sleep(1000);
} catch (interruptedexception e) {
e.printstacktrace();
}
new thread(()->{
demo.mylock();
demo.myunlock();
},"t2").start();
}
public void mylock(){
thread thread=thread.currentthread();
system.out.println(thread.currentthread().getname()+"\t come in");
//如果当前占用的线程为null，则尝试获取更新
while(!threadatomicreference.compareandset(null,thread)){
}
}
public void myunlock(){
thread thread=thread.currentthread();
//释放锁，将占用的线程设置为null
threadatomicreference.compareandset(thread,null);
system.out.println(thread.currentthread().getname()+"\t unlocked");
}
}
读写锁
独占锁：该锁一次只能被一个线程持有，如 reentrantlock 和 synchronized。
共享锁：该锁可以被多个线程持有。
reentrantreadwritelock 中，读锁是共享锁，写锁时独占锁。读读共享保证并发性，读写互斥。
并发工具类
countdownlatch
countdownlatch 的作用是让一些线程阻塞直到另外一些线程完成一系列操作后才被唤醒。
countdownlatch 在初始时设置一个数值，当一个或者多个线程使用 await() 方法时，这些线程会被阻塞。其余线程调用 countdown() 方法，将计数器减去1，当计数器为0时，调用 await() 方法被阻塞的线程会被唤醒，继续执行。
可以理解为，等大家都走了，保安锁门。
cyclicbarrier
cyclicbarrier 是指可以循环使用的屏障，让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障，屏障才会开门，被屏障拦截的线程才会继续工作，线程进入屏障通过 await() 方法。
可以理解为，大家都到齐了，才能开会。
semaphore
信号量用于：
可以理解为，多个车抢停车场的多个车位。当进入车位时，调用 acquire() 方法占用资源。当离开时，调用 release() 方法释放资源。
阻塞队列
阻塞队列首先是一个队列，所起的作用如下：
试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他线程向空的队列中插入新的元素。同样的，试图向已满的阻塞队列中添加新元素的线程同样会被阻塞，直到其他线程从队列中移除元素使得队列重新变得空闲起来并后序新增。
阻塞：阻塞是指在某些情况下会挂起线程，即阻塞，一旦条件满足，被挂起的线程又会自动被唤醒。
优点：blockingqueue 能帮助我们进行线程的阻塞和唤醒，而无需关心何时需要阻塞线程，何时需要唤醒线程。同时兼顾了效率和线程安全。
阻塞队列的架构
blokcingqueue 接口实现了 queue 接口，该接口有如下的实现类：
阻塞队列的方法
| 方法类型 | 抛出异常 | 特殊值 | 阻塞 | 超时 |
|---|---|---|---|---|
| 插入 | add(e) | offer(e) | put(e) | offer(e,time,unit) |
| 移除 | remove() | poll() | take() | poll(time,unit) |
| 检查 | element() | peek() | 无 | 无 |
生产者消费者模式
方式1. 使用lock
class sharedata {
private int number = 0;
private lock lock = new reentrantlock();
private condition condition = lock.newcondition();
public void increment() throws exception {
lock.lock();
try {
//判断
while (number != 0) {
condition.await();
}
//干活
number++;
system.out.println(thread.currentthread().getname() + " produce\t" + number);
//通知唤醒
condition.signalall();
} catch (exception e) {
e.printstacktrace();
} finally {
lock.unlock();
}
}
public void decrement()throws exception{
lock.lock();
try {
//判断
while (number == 0) {
condition.await();
}
//干活
number--;
system.out.println(thread.currentthread().getname() + " consume\t" + number);
//通知唤醒
condition.signalall();
} catch (exception e) {
e.printstacktrace();
} finally {
lock.unlock();
}
}
}
/**
* 一个初始值为0的变量，两个线程交替操作，一个加1一个减1,重复5次
* 1. 线程 操作 资源类
* 2. 判断 干活 通知
* 3. 防止虚假唤醒机制:判断的时候要用while而不是用if
*/
public class produceconsumetraditionaldemo {
public static void main(string[] args) {
sharedata data=new sharedata();
new thread(()->{
for (int i = 0; i < 5 ; i++) {
try {
data.increment();
} catch (exception e) {
e.printstacktrace();
}
}
},"a").start();
new thread(()->{
for (int i = 0; i < 5 ; i++) {
try {
data.decrement();
} catch (exception e) {
e.printstacktrace();
}
}
},"b").start();
}
}
打印结果
a produce 1
b consume 0
a produce 1
b consume 0
a produce 1
b consume 0
a produce 1
b consume 0
a produce 1
b consume 0
方法2：使用阻塞队列
public class produceconsumeblockingqueuedemo {
public static void main(string[] args) {
shareddata data=new shareddata(new arrayblockingqueue<>(10));
new thread(()-> {
system.out.println(thread.currentthread().getname() + "\t生产线程启动");
try {
data.produce();
} catch (interruptedexception e) {
e.printstacktrace();
}
},"producer").start();
new thread(()-> {
system.out.println(thread.currentthread().getname() + "\t消费线程启动");
try {
data.consume();
} catch (interruptedexception e) {
e.printstacktrace();
}
},"consumer").start();
try {
thread.sleep(3000);
} catch (interruptedexception e) {
e.printstacktrace();
}
data.stop();
system.out.println("停止");
}
}
class shareddata{
private volatile boolean flag=true;
private atomicinteger atomicinteger=new atomicinteger();
blockingqueue<string> blockingqueue=null;
public shareddata(blockingqueue<string> blockingqueue) {
this.blockingqueue = blockingqueue;
system.out.println(blockingqueue.getclass().getname());
}
public void produce() throws interruptedexception {
string data=null;
boolean ret;
while(flag){
data=""+atomicinteger.incrementandget();
ret=blockingqueue.offer(data,2l,timeunit.seconds);
if(ret){
system.out.println(thread.currentthread().getname()+"\t插入"+data+"成功");
}else{
system.out.println(thread.currentthread().getname()+"\t插入"+data+"失败");
}
timeunit.seconds.sleep(1);
}
system.out.println("生产结束，flag=false");
}
public void consume() throws interruptedexception {
string ret=null;
while(flag){
ret=blockingqueue.poll(2l,timeunit.seconds);
if(null==ret||ret.equalsignorecase("")){
system.out.println(flag=false);
system.out.println(thread.currentthread().getname()+"\t消费等待超时退出");
return;
}
system.out.println(thread.currentthread().getname() + "\t消费" + ret + "成功");
}
}
public void stop(){
flag=false;
}
}
使用阻塞队列+原子类+volatile变量的方式。
打印结果如下：
java.util.concurrent.arrayblockingqueue
producer 生产线程启动
consumer 消费线程启动
producer 插入1成功
consumer 消费1成功
producer 插入2成功
consumer 消费2成功
producer 插入3成功
consumer 消费3成功
停止
生产结束，flag=false
false
consumer 消费等待超时退出
synchronized 和 lock 的区别
案例：三个线程循环打印
class sharedata{
private int number=1;
private lock lock=new reentrantlock();
public void printa(){
lock.lock();
condition conditiona=lock.newcondition();
try{
while(number!=1){
conditiona.await();
}
for (int i = 0; i < 5; i++) {
system.out.println(thread.currentthread().getname()+"\t"+i);
}
number=2;
conditiona.signal();
}catch (exception e){
e.printstacktrace();
} finally {
lock.unlock();
}
}
public void printb(){
lock.lock();
condition conditionb=lock.newcondition();
try{
while(number!=2){
conditionb.await();
}
for (int i = 0; i < 10; i++) {
system.out.println(thread.currentthread().getname()+"\t"+i);
}
number=3;
conditionb.signal();
}catch (exception e){
e.printstacktrace();
} finally {
lock.unlock();
}
}
public void printc(){
lock.lock();
condition conditionc=lock.newcondition();
try{
//判断
while(number!=3){
conditionc.await();
}
//干活
for (int i = 0; i < 15; i++) {
system.out.println(thread.currentthread().getname()+"\t"+i);
}
number=1;
//通知
conditionc.signal();
}catch (exception e){
e.printstacktrace();
} finally {
lock.unlock();
}
}
public static void main(string[] args) {
sharedata data=new sharedata();
new thread(() -> data.printa(),"a").start();
new thread(() -> data.printb(),"b").start();
new thread(() -> data.printc(),"c").start();
}
}
线程池
创建线程
thread的构造函数中并没有传入 callable 的方式，但是可以传入 runnable 接口:
thread thread=new thread(runnable runnable, string name);。为了使用 callable 接口，我们需要使用到 futuretask 类。 futuretask 类实现了 runnablefuture 这一接口，而 runnablefutre 又是 future 的子接口，因此 futuretask 可以作为参数使用上述的 thread 构造函数。同时， futuretask 本身构造函数可以传入 callable 。
class mythread implements callable<integer>{
@override
public integer call() {
system.out.println("come in callable");
return 2019;
}
}
class main{
public static void main(string [] args){
futuretask<integer> futuretask = new futuretask<>(new mythread2());
thread t1=new thread(futuretask,"a");
}
}
线程池架构
除此之外，还有 executors 工具类。
threadpoolexecutor
线程池有七大参数：
public threadpoolexecutor(
int corepoolsize,//线程池常驻核心线程数
int maximumpoolsize,//线程池能容纳同时执行最大线程数
long keepalivetime,//多余的空闲线程的存活时间，当前线程池线程数量超过core，空闲时间达到keepalivetime，多余空闲线程会被销毁直到只剩下core个
timeunit unit,
blockingqueue<runnable> workqueue,//被提交尚未被执行的任务队列
threadfactory threadfactory,//创建线程的线程工厂
rejectedexecutionhandler handler//拒绝策略
)
{...}
处理流程如下：
拒绝策略
在 jdk 中有四种内置的拒绝策略，均实现了 rejectedexecutionhandler 接口。
三种常用线程池
1、executors.newfixedthreadpool(int)
创建固定容量的线程池，控制最大并发数，超出的线程在队列中等待。
return new threadpoolexecutor(nthreads, nthreads, 0l, timeunit.milliseconds, new linkedblockingqueue<runnable>());
其中 corepoolsize 和 maximumpoolsize 值是相等的，并且使用的是 linkedblockingqueue。
适用于执行长期的任务，性能比较高。
2、executors.newsinglethreadexecutor()
创建了一个单线程的线程池，只会用唯一的工作线程来执行任务，保证所有任务按照顺序执行。
return new finalizabledelegatedexecutorservice (new threadpoolexecutor(1, 1, 0l, timeunit.milliseconds, new linkedblockingqueue<runnable>()));
其中 corepoolsize 和 maximumpoolsize 都设置为1，使用的也是 linkedblockingqueue。
适用于一个任务一个任务执行的场景。
3、executors.newcachedthreadpool()
创建了一个可缓存的线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，没有可以回收的，则新建线程。
return new threadpoolexecutor(0, integer.max_value, 60l, timeunit.seconds, new synchronousqueue<runnable>());
设置 corepoolsize 为0， maximumpoolsize 设置为 integer.max_value，使用的是 synchronousqueue。来了任务就创建线程执行，线程空闲超过60秒后销毁。
适用于执行很多短期异步的小程序或者负载比较轻的服务器。
工作中使用什么样的线程池
在阿里巴巴java开发手册中有如下规定：
如何设置线程池的线程数目
runtime.getruntime().availableprocessors()获取当前设备的cpu个数。
死锁
产生死锁的原因
死锁是指两个或两个以上的进程在执行过程中，因为争夺资源造成的互相等待的现象。
死锁需要满族的四大条件如下：
产生死锁的主要原因有：
死锁实例
class holdlockthread implements runnable{
private string lock1;
private string lock2;
public holdlockthread(string lock1, string lock2) {
this.lock1 = lock1;
this.lock2 = lock2;
}
@override
public void run() {
synchronized (lock1){
system.out.println(thread.currentthread().getname()+"\t持有"+lock1+"\t尝试获取"+lock2);
try {
thread.sleep(2000);
} catch (interruptedexception e) {
e.printstacktrace();
}
synchronized (lock2){
system.out.println(thread.currentthread().getname()+"\t持有"+lock1+"\t尝试获取"+lock2);
}
}
}
}
public class deadlockdemo {
public static void main(string[] args) {
string locka="locka";
string lockb="lockb";
new thread(new holdlockthread(locka,lockb),"thread1").start();
new thread(new holdlockthread(lockb,locka),"thread2").start();
}
}
输出如下结果，程序并没有终止。
thread2 持有lockb 尝试获取locka
thread1 持有locka 尝试获取lockb
死锁定位分析
使用 jps ，类似于 linux 中的 ps 命令。
在上述 java 文件中，使用 idea 中的 open in terminal，或者在该文件目录下使用 cmd 命令行工具。
首先使用 jps -l命令，类似于ls -l命令，输出当前运行的 java 线程，从中能得知 deadlockdemo 线程的线程号。
然后，使用jstack threadid来查看栈信息。输出如下：
java stack information for the threads listed above:
===================================================
"thread2":
at interview.jvm.deadlock.holdlockthread.run(deadlockdemo.java:22)
- waiting to lock <0x00000000d6240328> (a java.lang.string)
- locked <0x00000000d6240360> (a java.lang.string)
at java.lang.thread.run(thread.java:748)
"thread1":
at interview.jvm.deadlock.holdlockthread.run(deadlockdemo.java:22)
- waiting to lock <0x00000000d6240360> (a java.lang.string)
- locked <0x00000000d6240328> (a java.lang.string)
at java.lang.thread.run(thread.java:748)found 1 deadlock.
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对移动技术网的支持。
如对本文有疑问， 点击进行留言回复！！
Springboot项目因为kackson版本问题启动报错解决方案
Java多线程下的其他组件之CyclicBarrier、Callable、Future和FutureTask详解
网友评论