Java多线程可重入锁例子解析

“可重入锁”的概念是:自己可以再次获得自己的内部锁。比如有一条线程获得了某个对象的锁,此时这个对象还没有释放,当其再次想获得这个对象的锁的时候还是可以获得的,如果不可锁重入的话,就会造成死锁。

class sysTest{
    synchronized void test1(String str){
        System.out.println(str+"1");
        test2(str);
        System.out.println("end" + str);
    }

    synchronized void test2(String str){
        System.out.println(str+"2");
    }
}

class myThread extends Thread{
    String str = null;
    public myThread(String str) {
        this.str = str;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        new sysTest().test1(str);
    }
}

public class synchronizedTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        myThread th1 = new myThread("1str");
        myThread th2 = new myThread("2str");
        th1.start();
        th2.start();
    }

}

在加粗的sychronized在的时候结果会有下面,结果不唯一的:

1str1

2str1

1str2

2str2

end2str

end1str

在加粗的sychronized去掉的时候结果会有下面,结果唯一的:

1str1

1str2

end1str

2str1

2str2

end2str

在这里必须要认识到,加一个sychronized方法里调用sychronized方法会造成不同步,需要注意。原因是两个锁的问题,

这个时候使用可重入概念解决的话,就要使用对象锁,因为在sychronized()代码块中再次获得该锁就会可以得到:

class sysTest{
    static Object object = new Object();
     void test1(String str){
         synchronized(object){
             System.out.println(str+"1");
                test2(str);
                System.out.println("end" + str);
         }

    }

    void test2(String str){
        synchronized(object){
        System.out.println(str+"2");
        }
    }
}

class myThread extends Thread{
    String str = null;
    public myThread(String str) {
        this.str = str;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        new sysTest().test1(str);
    }
}

public class synchronizedTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        myThread th1 = new myThread("1str");
        myThread th2 = new myThread("2str");
        th1.start();
        th2.start();
    }

}
结果:
1str1
1str2
end1str
2str1
2str2
end2str
时间: 2024-11-05 18:42:19

Java多线程可重入锁例子解析的相关文章

java 多线程-可重入锁

可重入锁:锁可以连续使用计数器+判断进入的线程是不是已经锁定的线程,如果是那就不用等待,直接使用 public class my { public static void main(String[]args) { my m=new my(); m.test(); } public void test() { synchronized(this)//第一次获得锁 { while(true) { synchronized(this)//第二次获得锁,假如没有可重入锁,将会造成死锁 { System.

java中可重入锁和自旋锁

1.可重入锁: 也称为递归锁,当外层函数获得该锁之后,内层递归函数仍有获取该锁的代码,结果不受影响: java中的synchronized  ReentrantLock都是可重的 举例: public class Test implements Runnable{ public synchronized void get(){ System.out.println(Thread.currentThread().getId()); set(); } public synchronized void

java ReentrantLock可重入锁的使用场景

摘要 从使用场景的角度出发来介绍对ReentrantLock的使用,相对来说容易理解一些. 场景1:如果发现该操作已经在执行中则不再执行(有状态执行) a.用在定时任务时,如果任务执行时间可能超过下次计划执行时间,确保该有状态任务只有一个正在执行,忽略重复触发.b.用在界面交互时点击执行较长时间请求操作时,防止多次点击导致后台重复执行(忽略重复触发). 以上两种情况多用于进行非重要任务防止重复执行,(如:清除无用临时文件,检查某些资源的可用性,数据备份操作等) [java] view plain

java 可重入锁ReentrantLock的介绍

一个小例子帮助理解 话说从前有一个村子,在这个村子中有一口水井,家家户户都需要到这口井里打水喝.由于井水有限,大家只能依次打水.为了实现家家有水喝,户户有水用的目标,村长绞尽脑汁,最终想出了一个比较合理的方案. 首先,在水井边上安排一个看井人,负责维持秩序. 然后,打水时,以家庭为单位,哪个家庭任何人先到井边,就可以先打水,而且如果一个家庭占到了打水权,其家人这时候过来打水不用排队.而那些没有抢占到打水权的人,一个一个挨着在井边排成一队,先到的排在前面. 最后,打水的人打完水以后就告诉看井人,看

Java 多线程 重入锁

作为关键字synchronized的替代品(或者说是增强版),重入锁是synchronized的功能扩展.在JDK 1.5的早期版本中,重入锁的性能远远好于synchronized,但从JDK 1.6开始,JDK优化了synchronized,使两者性能差距不大.重入锁使用java.util.concurrent.locks.ReentrantLock类来实现. 使用重入锁可以指定何时加锁和何时释放锁,对逻辑控制的灵活性远远好于synchronized,退出临界区时必须释放锁.之所以称为重入锁,

聊聊高并发(二十七)解析java.util.concurrent各个组件(九) 理解ReentrantLock可重入锁

这篇讲讲ReentrantLock可重入锁,JUC里提供的可重入锁是基于AQS实现的阻塞式可重入锁.这篇 聊聊高并发(十六)实现一个简单的可重入锁 模拟了可重入锁的实现.可重入锁的特点是: 1. 是互斥锁,基于AQS的互斥模式实现,也就是说同时只有一个线程进入临界区,唤醒下一个线程时也只能释放一个等待线程 2. 可重入,通过设置了一个字段exclusiveOwnerThread来标示当前获得锁的线程.获取锁操作是,如果当前线程是已经获得锁的线程,那么获取操作成功.把当前状态作为获得锁次数的计数器

java多线程---重入锁ReentrantLock

1.定义 重入锁ReentrantLock,支持重入的锁,表示一个线程对资源的重复加锁. 2.底层实现 每个锁关联一个线程持有者和计数器,当计数器为0时表示该锁没有被任何线程持有,那么任何线程都可能获得该锁而调用相应的方法:成功后,JVM会记下锁的持有线程,并且将计数器置为1:此时其它线程请求该锁,则必须等待:而该持有锁的线程如果再次请求这个锁,就可以再次拿到这个锁,同时计数器会递增:当线程退出同步代码块时,计数器会递减,如果计数器为0,则释放该锁. 3.使用样例 eg: import java

JAVA多线程重入锁ReentrantLock应用

package concurrent; import java.util.concurrent.*; import java.util.concurrent.locks.ReentrantLock; /** * @Auther:zhl * @Date:2019/7/13 * @Description: 并发测试,重入锁ReentrantLock解决并发问题 */ public class ConcurrentSample { //并发线程数量 private static int users =

Java 中15种锁的介绍:公平锁,可重入锁,独享锁,互斥锁,乐观锁,分段锁,自旋锁等等(转)

Java 中15种锁的介绍 在读很多并发文章中,会提及各种各样锁如公平锁,乐观锁等等,这篇文章介绍各种锁的分类.介绍的内容如下: 公平锁 / 非公平锁 可重入锁 / 不可重入锁 独享锁 / 共享锁 互斥锁 / 读写锁 乐观锁 / 悲观锁 分段锁 偏向锁 / 轻量级锁 / 重量级锁 自旋锁 上面是很多锁的名词,这些分类并不是全是指锁的状态,有的指锁的特性,有的指锁的设计,下面总结的内容是对每个锁的名词进行一定的解释. 公平锁 / 非公平锁 公平锁 公平锁是指多个线程按照申请锁的顺序来获取锁. 非公