java生产环境调优(6) 模拟一次死锁,以及死锁的定位

最新推荐文章于 2022-05-10 10:22:20 发布
最新推荐文章于 2022-05-10 10:22:20 发布
阅读量537 收藏 1
点赞数
分类专栏： java生产环境调优 文章标签： 死锁模拟 jstack
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a897180673/article/details/103219445
版权

以前在看慕课网考试视频的时候, 分析cpu飙高 ,很自然的想到使用jstack去进行定位分析,相对而言,这一块还是比价的容易去定位的.
后来在一次面试的时候,面试官问我你在现实环境中遇到过死锁么.
当时还是比较蒙的,现实生活都很难遇到多线程,何来死锁.
后来面试官又问 你知道怎么定位死锁么.这个可把我难住了,面试官接着说 就是你刚才说的jstack,那个时候才恍然大悟,死锁本质不就是cpu卡住了么.jstack不就是看cpu执行栈的么,惭愧啊,惭愧.

ok ,回到正题,最近看到极客时间的老师的讲到死锁的问题,决定搞代码试一试

死锁本质上是2个线程抢2个资源,要么都抢到,要么都抢不到,偏偏有一种可能2个线程各自抢到一个,互相等对方释放,这个时候就会造成僵局,造成永久阻塞

ok,上代码.


public class DeadLock extends Thread {

    private String firstKey;
    private String secondKey;

    public DeadLock(String firstKey,String secondKey){
        this.firstKey=firstKey;
        this.secondKey=secondKey;
    }

    @Override
    public void run() {
        synchronized (firstKey){
            System.out.println(Thread.currentThread().getName()+"获得第一个锁,马上尝试获取第二个锁");

            try {
                Thread.sleep(1000);
                synchronized (secondKey){
                    System.out.println(Thread.currentThread().getName()+"获取到第二个锁");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }


    public static void main(String[] args) {

        String firstKey="firstKey";
        String secondKey="secondKey";
        DeadLock deadLockTest1=new DeadLock(firstKey,secondKey);
        DeadLock deadLockTest2=new DeadLock(secondKey,firstKey);

        deadLockTest1.start();
        deadLockTest2.start();
    }
}

首先定义两把锁,firstKey和secondKey 分别开2个线程,
一个是先获取firstKey 再获取secondKey
一个是先获取secondKey 再获取 firstKey

为了防止任何一个线程获取成功后继续获取第二个锁,中间加了一个延时.

ok 跑起来看一看

在这里插入图片描述

可以看到两个线程都没有继续往下走,死锁演示成功了.

那么如何定位了?之前说了很简单 jstack

先jps 看下这个应用的进程id,再jstack导出线程栈看看

2019-11-23 22:31:39
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.181-b13 mixed mode):

"Attach Listener" #14 daemon prio=9 os_prio=31 tid=0x00007fb7fc8e9800 nid=0x5903 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"DestroyJavaVM" #13 prio=5 os_prio=31 tid=0x00007fb7fc0a3000 nid=0x2703 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Thread-1" #12 prio=5 os_prio=31 tid=0x00007fb7fc0a2000 nid=0x5803 waiting for monitor entry [0x000070000c45d000]
   java.lang.Thread.State: BLOCKED (on object monitor)
	at com.example.demo.jikexueyuan.DeadLock.run(DeadLock.java:21)
	- waiting to lock <0x000000076acf7da0> (a java.lang.String)
	- locked <0x000000076acf7dd8> (a java.lang.String)

"Thread-0" #11 prio=5 os_prio=31 tid=0x00007fb7fc05a800 nid=0x5703 waiting for monitor entry [0x000070000c35a000]
   java.lang.Thread.State: BLOCKED (on object monitor)
	at com.example.demo.jikexueyuan.DeadLock.run(DeadLock.java:21)
	- waiting to lock <0x000000076acf7dd8> (a java.lang.String)
	- locked <0x000000076acf7da0> (a java.lang.String)

"Service Thread" #10 daemon prio=9 os_prio=31 tid=0x00007fb7fe939800 nid=0xa803 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C1 CompilerThread3" #9 daemon prio=9 os_prio=31 tid=0x00007fb7fe029800 nid=0x5503 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread2" #8 daemon prio=9 os_prio=31 tid=0x00007fb7fd846000 nid=0x4203 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread1" #7 daemon prio=9 os_prio=31 tid=0x00007fb7fd845800 nid=0x3f03 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread0" #6 daemon prio=9 os_prio=31 tid=0x00007fb7fc05a000 nid=0x4403 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Monitor Ctrl-Break" #5 daemon prio=5 os_prio=31 tid=0x00007fb7fc064000 nid=0x3e03 runnable [0x000070000bc45000]
   java.lang.Thread.State: RUNNABLE
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
	at java.net.SocketInputStream.read(SocketInputStream.java:171)
	at java.net.SocketInputStream.read(SocketInputStream.java:141)
	at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
	at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
	at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
	- locked <0x000000076adcb018> (a java.io.InputStreamReader)
	at java.io.InputStreamReader.read(InputStreamReader.java:184)
	at java.io.BufferedReader.fill(BufferedReader.java:161)
	at java.io.BufferedReader.readLine(BufferedReader.java:324)
	- locked <0x000000076adcb018> (a java.io.InputStreamReader)
	at java.io.BufferedReader.readLine(BufferedReader.java:389)
	at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:64)

"Signal Dispatcher" #4 daemon prio=9 os_prio=31 tid=0x00007fb7fc039000 nid=0x3c03 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Finalizer" #3 daemon prio=8 os_prio=31 tid=0x00007fb7fb00c000 nid=0x4d03 in Object.wait() [0x000070000ba3f000]
   java.lang.Thread.State: WAITING (on object monitor)
	at java.lang.Object.wait(Native Method)
	- waiting on <0x000000076ab08ed0> (a java.lang.ref.ReferenceQueue$Lock)
	at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:144)
	- locked <0x000000076ab08ed0> (a java.lang.ref.ReferenceQueue$Lock)
	at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:165)
	at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:216)

"Reference Handler" #2 daemon prio=10 os_prio=31 tid=0x00007fb7fc814800 nid=0x4e03 in Object.wait() [0x000070000b93c000]
   java.lang.Thread.State: WAITING (on object monitor)
	at java.lang.Object.wait(Native Method)
	- waiting on <0x000000076ab06bf8> (a java.lang.ref.Reference$Lock)
	at java.lang.Object.wait(Object.java:502)
	at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
	- locked <0x000000076ab06bf8> (a java.lang.ref.Reference$Lock)
	at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

"VM Thread" os_prio=31 tid=0x00007fb7fe024800 nid=0x3703 runnable 

"GC task thread#0 (ParallelGC)" os_prio=31 tid=0x00007fb7fc004000 nid=0x2007 runnable 

"GC task thread#1 (ParallelGC)" os_prio=31 tid=0x00007fb7fc004800 nid=0x2a03 runnable 

"GC task thread#2 (ParallelGC)" os_prio=31 tid=0x00007fb7fc005000 nid=0x2c03 runnable 

"GC task thread#3 (ParallelGC)" os_prio=31 tid=0x00007fb7fc005800 nid=0x2e03 runnable 

"GC task thread#4 (ParallelGC)" os_prio=31 tid=0x00007fb7fd800000 nid=0x5303 runnable 

"GC task thread#5 (ParallelGC)" os_prio=31 tid=0x00007fb7fc006800 nid=0x2f03 runnable 

"GC task thread#6 (ParallelGC)" os_prio=31 tid=0x00007fb7fd801000 nid=0x3103 runnable 

"GC task thread#7 (ParallelGC)" os_prio=31 tid=0x00007fb7fd801800 nid=0x3203 runnable 

"GC task thread#8 (ParallelGC)" os_prio=31 tid=0x00007fb7fd802000 nid=0x3403 runnable 

"GC task thread#9 (ParallelGC)" os_prio=31 tid=0x00007fb7fc007000 nid=0x3603 runnable 

"VM Periodic Task Thread" os_prio=31 tid=0x00007fb7fc8e9000 nid=0xa603 waiting on condition 

JNI global references: 15


Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x00007fb7fc023358 (object 0x000000076acf7da0, a java.lang.String),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x00007fb7fc020968 (object 0x000000076acf7dd8, a java.lang.String),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
	at com.example.demo.jikexueyuan.DeadLock.run(DeadLock.java:21)
	- waiting to lock <0x000000076acf7da0> (a java.lang.String)
	- locked <0x000000076acf7dd8> (a java.lang.String)
"Thread-0":
	at com.example.demo.jikexueyuan.DeadLock.run(DeadLock.java:21)
	- waiting to lock <0x000000076acf7dd8> (a java.lang.String)
	- locked <0x000000076acf7da0> (a java.lang.String)

Found 1 deadlock.

看最后一行,jstack真的是很智能,它自动的告诉我们发现了一个死锁,这个对开发这而言很友好,因为不需要开发者专门去定位了.

看到这里我立刻想到了另外一个问题,那就是使用非synchronize锁,以前面试官问我,java锁的分类,那个时候不太清楚.面试官问我除了jvm原生的,还有啥,当时我不知道啊.哎.

现在好歹知道了一些,今天突然来了兴趣试一下ReentrantLock

看看用这个来实现死锁,jstack会有什么反应

ok,上代码

import java.util.concurrent.locks.ReentrantLock;

public class DeadLock2 extends Thread {
    ReentrantLock firstLock;
    ReentrantLock secondLock;

    public DeadLock2(ReentrantLock firstLock, ReentrantLock secondLock) {
        this.firstLock = firstLock;
        this.secondLock = secondLock;
    }

    @Override
    public void run() {
        firstLock.lock();
        System.out.println(Thread.currentThread().getName() + "获得第一个锁,马上尝试获取第二个锁");
        try {
            Thread.sleep(1000);
            secondLock.lock();
            System.out.println(Thread.currentThread().getName() + "获取到第二个锁");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ReentrantLock firstLock = new ReentrantLock();
        ReentrantLock secondLock = new ReentrantLock();

        DeadLock2 deadLockTest1=new DeadLock2(firstLock,secondLock);
        DeadLock2 deadLockTest2=new DeadLock2(secondLock,firstLock);

        deadLockTest1.start();
        deadLockTest2.start();
    }
}

ok啦,跑起来看看

在这里插入图片描述
效果是一样的,也出现了死锁,老规矩,jstack 看下

2019-11-23 22:51:05
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.181-b13 mixed mode):

"Attach Listener" #14 daemon prio=9 os_prio=31 tid=0x00007fc5c004b800 nid=0x5903 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"DestroyJavaVM" #13 prio=5 os_prio=31 tid=0x00007fc5bf889800 nid=0x2803 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Thread-1" #12 prio=5 os_prio=31 tid=0x00007fc5bf830800 nid=0x5803 waiting on condition [0x000070000af4d000]
   java.lang.Thread.State: WAITING (parking)
	at sun.misc.Unsafe.park(Native Method)
	- parking to wait for  <0x000000076acfda50> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
	at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
	at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
	at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
	at com.example.demo.jikexueyuan.DeadLock2.run(DeadLock2.java:20)

"Thread-0" #11 prio=5 os_prio=31 tid=0x00007fc5c2800000 nid=0xa503 waiting on condition [0x000070000ae4a000]
   java.lang.Thread.State: WAITING (parking)
	at sun.misc.Unsafe.park(Native Method)
	- parking to wait for  <0x000000076acfda80> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
	at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
	at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
	at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
	at com.example.demo.jikexueyuan.DeadLock2.run(DeadLock2.java:20)

"Service Thread" #10 daemon prio=9 os_prio=31 tid=0x00007fc5bda46800 nid=0x5603 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C1 CompilerThread3" #9 daemon prio=9 os_prio=31 tid=0x00007fc5bda45800 nid=0x5503 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread2" #8 daemon prio=9 os_prio=31 tid=0x00007fc5bda45000 nid=0x3f03 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread1" #7 daemon prio=9 os_prio=31 tid=0x00007fc5bf82c800 nid=0x4203 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread0" #6 daemon prio=9 os_prio=31 tid=0x00007fc5bf82b800 nid=0x4403 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Monitor Ctrl-Break" #5 daemon prio=5 os_prio=31 tid=0x00007fc5bf82a000 nid=0x3d03 runnable [0x000070000a735000]
   java.lang.Thread.State: RUNNABLE
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
	at java.net.SocketInputStream.read(SocketInputStream.java:171)
	at java.net.SocketInputStream.read(SocketInputStream.java:141)
	at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
	at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
	at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
	- locked <0x000000076adcb018> (a java.io.InputStreamReader)
	at java.io.InputStreamReader.read(InputStreamReader.java:184)
	at java.io.BufferedReader.fill(BufferedReader.java:161)
	at java.io.BufferedReader.readLine(BufferedReader.java:324)
	- locked <0x000000076adcb018> (a java.io.InputStreamReader)
	at java.io.BufferedReader.readLine(BufferedReader.java:389)
	at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:64)

"Signal Dispatcher" #4 daemon prio=9 os_prio=31 tid=0x00007fc5be001000 nid=0x4503 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Finalizer" #3 daemon prio=8 os_prio=31 tid=0x00007fc5c0046800 nid=0x4903 in Object.wait() [0x000070000a52f000]
   java.lang.Thread.State: WAITING (on object monitor)
	at java.lang.Object.wait(Native Method)
	- waiting on <0x000000076ab08ed0> (a java.lang.ref.ReferenceQueue$Lock)
	at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:144)
	- locked <0x000000076ab08ed0> (a java.lang.ref.ReferenceQueue$Lock)
	at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:165)
	at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:216)

"Reference Handler" #2 daemon prio=10 os_prio=31 tid=0x00007fc5c0802000 nid=0x3303 in Object.wait() [0x000070000a42c000]
   java.lang.Thread.State: WAITING (on object monitor)
	at java.lang.Object.wait(Native Method)
	- waiting on <0x000000076ab06bf8> (a java.lang.ref.Reference$Lock)
	at java.lang.Object.wait(Object.java:502)
	at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
	- locked <0x000000076ab06bf8> (a java.lang.ref.Reference$Lock)
	at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

"VM Thread" os_prio=31 tid=0x00007fc5bf800800 nid=0x3203 runnable 

"GC task thread#0 (ParallelGC)" os_prio=31 tid=0x00007fc5bd809000 nid=0x2107 runnable 

"GC task thread#1 (ParallelGC)" os_prio=31 tid=0x00007fc5bd809800 nid=0x2a03 runnable 

"GC task thread#2 (ParallelGC)" os_prio=31 tid=0x00007fc5bd81b000 nid=0x5403 runnable 

"GC task thread#3 (ParallelGC)" os_prio=31 tid=0x00007fc5bd81b800 nid=0x2d03 runnable 

"GC task thread#4 (ParallelGC)" os_prio=31 tid=0x00007fc5c0000000 nid=0x5303 runnable 

"GC task thread#5 (ParallelGC)" os_prio=31 tid=0x00007fc5c0001000 nid=0x5103 runnable 

"GC task thread#6 (ParallelGC)" os_prio=31 tid=0x00007fc5c0001800 nid=0x4f03 runnable 

"GC task thread#7 (ParallelGC)" os_prio=31 tid=0x00007fc5c0002000 nid=0x4e03 runnable 

"GC task thread#8 (ParallelGC)" os_prio=31 tid=0x00007fc5c0002800 nid=0x4d03 runnable 

"GC task thread#9 (ParallelGC)" os_prio=31 tid=0x00007fc5c0003800 nid=0x3103 runnable 

"VM Periodic Task Thread" os_prio=31 tid=0x00007fc5bda47000 nid=0xa703 waiting on condition 

JNI global references: 15


Found one Java-level deadlock:
=============================
"Thread-1":
  waiting for ownable synchronizer 0x000000076acfda50, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by "Thread-0"
"Thread-0":
  waiting for ownable synchronizer 0x000000076acfda80, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
	at sun.misc.Unsafe.park(Native Method)
	- parking to wait for  <0x000000076acfda50> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
	at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
	at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
	at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
	at com.example.demo.jikexueyuan.DeadLock2.run(DeadLock2.java:20)
"Thread-0":
	at sun.misc.Unsafe.park(Native Method)
	- parking to wait for  <0x000000076acfda80> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
	at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
	at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
	at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
	at com.example.demo.jikexueyuan.DeadLock2.run(DeadLock2.java:20)

Found 1 deadlock.

也告诉了我们发现一个死锁

ReentrantLock 还有很多其他的功能比如定义公平锁,非公平锁, 条件等待 唤醒 等等. 用法上还是比synchronize要难很多的,而且一不小心用错了 往往就比较悲剧了.

平时开发中如果没有特别的情况,使用synchronize 就足够了,毕竟锁的获取释放等工作交给jvm去做就好了.

然而在面试中很多面试官都喜欢来一点深度.考察考察你

还能怎么办呢? 加油吧

在这里插入图片描述

翻身了,咸鱼!
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中常见的死锁以及解决方法代码
08-26
主要介绍了java中常见的死锁以及解决方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java.util.concurrent.locks.ReentrantLock原理分析
APlus
09-10 485
一、引言 ReentrantLock是JDK1.5引入的一种工具类：它可以实现可重入锁的功能。在分析它的原理之前，我们先来回顾下基础知识： 什么是可重入锁？ 可重入锁是一种可重复可递归调用的锁，在一个线程获取这个锁后，这个线程依然可以再次获得这个锁，而其它线程要想获得锁只能等到它全部释放之后。 比如： public class Test { static final Reen...
剖析java.util.concurrent锁
专注、专心、专业
10-27 1864
来自IBM的工程师齐尧，Raja Das和罗志达在本文中介绍了jucprofiler，这个alphaWorks上的工具用于剖析使用了java.util.concurrent类的多 核平台上的应用程序，而java.util.concurrent类则是在Java 5中引入的。 相关厂商内容 Flash Builder 4.5高级版试用版免费高速下载 1. 导言 程序的性能分析是应用
java.util.concurrent.locks包下的ReentrantLock类实现详解（一）
W_Hfly的博客
07-26 966
一、ReentrantLock 类介绍 我觉得学习Java源码一定要首先读读源码的注释文档。  官方注释文档解释到，该类作为一个提供可重入功能的锁，实现了Lock接口，提供了和synchronized类似的功能，并且提供了额外的功能以实现同步。 二、ReentrantLock中的相关属性和方法 属性 含义 Sync sync Sync为ReentrantLock中的静态内...
Java 程序死锁问题原理及解决方案(来源IBM开发者论坛本文作者文章)
09-03 2075
本文首先介绍了死锁发生的原因，并通过一个示例解释了死锁发生的前提情况。然后通过 JVM 的 jstack 工具演示了如何确定一个死锁的发生。最后对死锁的预防、恢复等方式进行了解释。 原文地址：https://www.ibm.com/developerworks/cn/java/j-lo-deadlock/
java多线程抢占资源_java 多线程争抢资源死锁
weixin_29027305的博客
02-13 882
多线程争抢资源死锁的原理就是，A线程正在持有锁1却想获取锁2，B线程正在持有锁2却要获取锁1代码如下：public class Main {static ReentrantLock lock1 = new ReentrantLock();static ReentrantLock lock2 = new ReentrantLock();static class Test1 implements Ru...
Java模拟死锁发生之演绎哲学家进餐问题案例详解
08-25
主要介绍了Java模拟死锁发生之演绎哲学家进餐问题,结合具体演绎哲学家进餐问题的案例形式详细分析了死锁机制与原理,需要的朋友可以参考下
Java 多线程死锁的产生以及如何避免死锁
08-25
主要介绍了Java 多线程死锁的产生以及如何避免死锁，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
详解Java的线程的优先级以及死锁
09-03
主要介绍了详解Java的线程的优先级以及死锁,线程是Java编程学习中的重要知识,需要的朋友可以参考下
一分钟用睡前小故事图解Java线程之死锁
12-22
Java线程之死锁深入理解Java线程安全——银行欠我400万！！！线程执行的六大状态一、故事引入二、死锁死锁的产生三、线程通信等待通知四、代码案例线程释放锁标记主线程通知MyThread线程主线程通知哪个线程？ 为了更...
死锁定位解决
to_real的博客
05-10 2634
死锁 死锁：是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。 死锁发生的原因 死锁的发生是由于资源竞争导致的，导致死锁的原因如下： 系统资源不足，如果系统资源充足，死锁出现的可能性就很低。 进程（线程）运行推进的顺序不合适。 资源分配不当等。 死锁发生的条件 死锁的发生的四个必要条件： 互斥条件：一个资源每次只能被一个进程使用。 占有且等待：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 不可强行占有：进程（线
聊聊高并发（二十七）解析java.util.concurrent各个组件（九） 理解ReentrantLock可重入锁
ITer_ZC的专栏
11-11 3624
这篇讲讲ReentrantLock可重入锁，JUC里提供的可重入锁是基于AQS实现的阻塞式可重入锁。这篇 聊聊高并发（十六）实现一个简单的可重入锁 模拟了可重入锁的实现。可重入锁的特点是： 1. 是互斥锁，基于AQS的互斥模式实现，也就是说同时只有一个线程进入临界区，唤醒下一个线程时也只能释放一个等待线程 2. 可重入，通过设置了一个字段exclusiveOwnerThread来标示当前获
从源码角度理解ReentrantLock（java.util.concurrent.locks.ReentrantLock）
Impassive_y的博客
04-19 725
文章目录一、ReentrantLock介绍二、ReentrantLock继承关系三、Sync3.1 主要实现的方法四、FairSync(公平锁)4.1 加锁4.2 加锁失败，进入等待4.3 释放锁五、非公平锁5.1 加锁5.2 释放锁六、其他方法 一、ReentrantLock介绍 ReentrantLock重入锁，能够实现对同一个资源的重复加锁，即当前线程重复申请资源的时候，在已经拥有锁的前提下...
Java性能调优工具
weixin_34034261的博客
11-13 149
1、JDK命令行工具 1.1、jps命令 jps用于列出Java的进程，jps可以增加参数，-m用于输出传递给Java进程的参数，-l用于输出主函数的完整路径，-v可以用于显示传递给jvm的参数。 jps -l -m -v 31427...
jstack，用于检测死锁
zhaozhenzuo的专栏
05-31 3719
java死锁检测
[java并发]读写锁ReentrantReadWriteLock里面的FairSync 和 NonfairSync
lucifer545的专栏
12-07 2886
背景介绍 最近转行做java后台了，对于java的并发完全不熟悉，于是到网上各种搜资料。 接到的一个任务是一个很简单从数据库里面读取一些表到内存里面，然后做一个缓存。 读数据库用的EJB3的Entity Bean； 服务是基于JBoss的MBean；访问接口是EJB3的stateless session bean； 因为session bean是多线程的方式访问Mbean的，所以要考虑内存
java.util.concurrent.locks.ReentrantLock重入锁源码解析
sunpy
09-07 1170
1.什么是重入锁 重入锁就是指重复进入锁，它表示该锁能够支持一个线程对资源的重复加锁。 2.重入锁所属包 package java.util.concurrent.locks; 3.重入锁继承与实现关系 public class ReentrantLock implements Lock, java.io.Serializable 4.重入锁的自定义同步器源码 重入锁Reentran
java.util.concurrent.locks.ReentrantLock 源码剖析
ZhangXL的专栏
02-28 405
ReentrantLock从jdk1.5开始引入，相对于synchronized关键字有较好的效率。方法摘要如下： 方法摘要  int getHoldCount()           查询当前线程保持此锁的次数。 protected  Thread getOwner()           返回目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回
一步步学习多线程(七) ReentrantLock
money9sun的博客
09-12 2014
ReentrantLock是一个锁，相对于synchronized, 这个锁更灵活，可以灵活的加锁和解锁。 我们先看一个例子 public class ReenterLock implements Runnable {     public static ReentrantLock lock = new ReentrantLock();     public static int count ...
Java 如何定位一个死锁
最新发布
06-07
Java 中可以通过 jstack 命令来查看当前 Java 进程的线程堆栈信息，从而判断是否存在死锁。具体步骤如下： 1. 打开终端，进入 Java 进程所在的服务器或者本地主机； 2. 执行命令 jps，查看当前 Java 进程的 PID； 3...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值