7.java锁之可重入锁和递归锁代码验证 Synchronized以及ReentrantLock可重入锁演示程序

1.可重入锁（也叫做递归锁）

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。

ReentrantLock/synchronized就是一个典型的可重入锁。

可重入锁最大的作用是避免死锁。

2.代码

package com.mydemo;

public class SynchronizedReentrantLockDemo {//java锁之可重入锁和递归锁代码验证 Synchronized可入锁演示程序

    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSMS();

        },"t1").start();
        new Thread(()->{
            phone.sendSMS();

        },"t2").start();
    }
}
class Phone{
    public synchronized void sendSMS(){
        System.out.println(Thread.currentThread().getName()+"\t invoke sendSMS()");
        sendEmail();
    }

    public synchronized void sendEmail(){
        System.out.println(Thread.currentThread().getName()+"\t invoke sendEmail()");

    }
}

3.执行结果

t1     invoke sendSMS()
t1     invoke sendEmail()
t2     invoke sendSMS()
t2     invoke sendEmail()

 4.ReentrantLock可重入锁演示程序

package com.mydemo;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
    public static void main(String[] args) {
        Phone2 phone2 = new Phone2();
        new Thread(phone2,"t1").start();
        new Thread(phone2,"t2").start();

    }
}
class Phone2 implements Runnable{
    Lock lock=new ReentrantLock();
    public void getLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
        }
    }
    public void setLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t set Lock");
        } finally {
            lock.unlock();
        }
    }





    @Override
    public void run() {
        getLock();

    }
}

5.执行结果

t1     get Lock
t1     set Lock
t2     get Lock
t2     set Lock

 6.ReentrantLockDemo 

 

package com.mydemo;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
    public static void main(String[] args) {
        Phone2 phone2 = new Phone2();
        new Thread(phone2,"t1").start();
        new Thread(phone2,"t2").start();

    }
}
class Phone2 implements Runnable{
    Lock lock=new ReentrantLock();
    public void getLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
        }
    }
    public void setLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t set Lock");
        } finally {
            lock.unlock();
        }
    }





    @Override
    public void run() {
        getLock();

    }
}

7.执行结果

t1     getLock
t1     setLock
t2     getLock
t2     setLock