重入锁简介

                public class MyLock {
                    //标识锁是否可用  如果值为true代表当前有线程正在使用该锁，如果为false代表没有人用锁
                    private boolean isLocked=false;
                    //获取锁：加锁
                    public synchronized void lock() throws InterruptedException {
                        //判断当前该锁是否正在使用
                        while (isLocked){
                            wait();
                        }
                        //当前没有人使用情况下就占用该锁
                        isLocked=true;
                    }
                    //释放锁
                    public synchronized void unLock(){
                        //将当前锁资源释放
                        isLocked=false;
                        //唤起正在等待使用锁的线程
                        notify();
                    }
                }

                public class MyLockTest {
                    MyLock myLock=new MyLock();
                    //A业务方法
                    public void print() throws InterruptedException {
                        //获取一把锁
                        myLock.lock();
                        System.out.println("print业务方法");
                        doAdd();
                        //释放锁
                        myLock.unLock();
                    }

                    //B业务方法
                    public void doAdd() throws InterruptedException {
                        //获取一把锁
                        myLock.lock();
                        System.out.println("doAdd业务方法");
                        //释放锁
                        myLock.unLock();
                    }

                    public static void main(String[] args) throws InterruptedException {
                        MyLockTest test=new MyLockTest();
                        test.print();
                    }
                }

                public class MyLockTest {
                    //A业务方法
                    public synchronized void print() throws InterruptedException {
                        //获取了一把锁
                        System.out.println("print业务方法");

                        doAdd();

                    }

                    //B业务方法
                    public synchronized void doAdd() throws InterruptedException {
                        System.out.println("doAdd业务方法");
                        //释放锁
                    }

                    public static void main(String[] args) throws InterruptedException {
                        MyLockTest test=new MyLockTest();
                        test.print();
                    }
                }

                public class MyLockTest {
                    //创建锁对象
                    Lock lock=new ReentrantLock();
                    //A业务方法
                    public  void print() throws InterruptedException {
                        //获取了一把锁
                        lock.lock();
                        System.out.println("print业务方法");
                        doAdd();
                        //释放锁
                        lock.unlock();
                    }

                    //B业务方法
                    public  void doAdd() throws InterruptedException {
                        //获取了一把锁
                        lock.lock();
                        System.out.println("doAdd业务方法");
                        //释放锁
                        lock.unlock();
                    }

                    public static void main(String[] args) throws InterruptedException {
                        MyLockTest test=new MyLockTest();
                        test.print();
                    }
                }

                public ReentrantLock() {
                    //默认非公平锁
                    sync = new NonfairSync();
                }
                
                public ReentrantLock(boolean fair) {
                    //如果为true代表公平锁，否则为非公平锁
                    sync = fair ? new FairSync() : new NonfairSync();
                }
                
                
                public class MyReentrantLock {
                    //标识锁是否可用  如果值为true代表当前有线程正在使用该锁，如果为false代表没有人用锁
                    private boolean isLocked=false;
                    //当前线程
                    Thread lockedBy=null;
                    //加锁数量计数
                    Integer lockedCount=0;
                    //加锁
                    public synchronized void lock() throws InterruptedException {
                        //获取当前线程
                        Thread thread=Thread.currentThread();
                        //判断当前是否正在使用锁，如果正在使用则对比当前使用要使用锁的线程和之前使用锁的线程是否一致
                        //如果一致代表可以重入，继续使用锁，不会发生阻塞
                        //如果不一致代表当前不是一个线程，则等待
                        while (isLocked && thread!=lockedBy){
                            wait();
                        }
                        //占用锁
                        isLocked=true;
                        //计数+1
                        lockedCount++;
                        //赋值线程
                        lockedBy=thread;
                    }
                    //释放锁
                    public synchronized void unlock(){
                        //判断当前是否是用一个线程
                        if(Thread.currentThread()==this.lockedBy){
                            //锁使用计数器-1
                            lockedCount--;
                            //判断计数器是否为0，如果为0则释放锁，然后唤醒正在等待的线程
                            if(lockedCount==0){
                                isLocked=false;
                                notify();
                            }
                        }
                    }
                }