深入ReentrantLock底层原理01

深入ReentrantLock底层原理01

1、Thread线程

package top.juntech.lock;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        Thread t1 = new Thread(){

            public void run(){
                testSync();
            }
        };
        Thread t2 = new Thread(){

            public void run(){
                testSync();
            }
        };
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();

    }

    public static void testSync(){
           
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }

 


    }


}

在这里，我们的线程t1,t2同时调用了testSync方法,尽管有thread.sleep(2000)，但我们发现t1,t2几乎是同时打印出来的，为什么呢，在t1进入这个方法里面，虽然在睡眠但不影响主线程继续执行，接下来t2启动，那我们怎么使他们一前一后执行呢，答案时加锁。我们这里就将ReentranLock.

1、添加一个全局变量： ReentranLock reen = new ReentranLock(true);

2、在方法里面添加lock方法

3、释放锁

代码如下：

package top.juntech.lock;

import java.util.concurrent.locks.ReentrantLock;   //初始化锁对象

public class TestLock {
    static  ReentrantLock reentrantLock = new ReentrantLock(true);
    public static void main(String[] args) {
        Thread t1 = new Thread(){

            public void run(){
                testSync();
            }
        };
        Thread t2 = new Thread(){

            public void run(){
                testSync();
            }
        };
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();

    }

    public static void testSync(){
        try {
            reentrantLock.lock();   //加锁
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }

        }finally {
            reentrantLock.unlock();  //释放锁
        }


    }


}

这样，我们就可以看到t1打印完了过了2s左右，才开始打印t2.

2、思考

既然java里面有关键字sysnchronized，为什么还需要ReentranLock？

java中的线程是和操作系统中的线程是一一对应的，synchronized在执行多线程时，t1进入synchronized方法后，t2也想进去，它会让t2操作操作系统的一个函数，t2占用之后，会让操作系统的哪个函数产生阻塞，直到t1醒来，执行完释放，t2拿到锁之后，接着执行同步代码块。

2.1 多线程同步内部是如何实现的

wait/notify,synchronized ,ReentranLock

模拟一些同步的思路：

自旋锁：

volatile int status = 0;
void lock(){
    while(!compareAndSet(0,1)){
        
    }
    //lock
}
void unlock(){
    status = 0;
}
boolean compareAndSet(int except,int newValue){
    //compare  and  set操作,修改status成功返回true
}

缺点： 耗费cpu资源，没有竞争到锁的线程会一直占用cas操作。

思路：让得不到锁的线程让出cpu

不能用wait,因为wait是和sync一起使用的，单独使用会报错，且wait不只是拿来使线程阻塞的，它还可以用来线程通信。

yield+自旋锁

volatile int status = 0;
void lock(){
    while(!compareAndSet(0,1)){
       yield();//自己实现 
    }
    //lock
}
void unlock(){
    status = 0;
}
boolean compareAndSet(int except,int newValue){
    //compare  and  set操作,修改status成功返回true
}

要解决自旋锁的性能问题必须让竞争锁失败的的线程不空转，而是在获取不到锁的时候让出cpu,yeild()方法可以让出cpu;但是yield并不能完全解决问题，在线程数为2个时，可以使用，但线程数比较多的时候，就不适用了，因为yeild是由操作系统控制的。

yield方法，请参考：https://blog.csdn.net/zhuwei898321/article/details/72844506

sleep+自旋锁

volatile int status = 0;
void lock(){
    while(!compareAndSet(0,1)){
       sleep(10};//自己实现 
    }
    //lock --- 1s
}
void unlock(){
    status = 0;
}
boolean compareAndSet(int except,int newValue){
    //compare  and  set操作,修改status成功返回true
}

缺点：睡眠时间不确定,易造成cpu资源浪费

park+自旋锁

这里要使用的是UNSAFE类里面的park方法,下面是park方法的具体使用

package top.juntech.lock;


import java.util.concurrent.locks.LockSupport;

public class TestPark {

    public static void main(String[] args) {
        Thread t1 = new Thread(){

            public void run(){
                testSync();
            }
        };
        t1.setName("t1");
        t1.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("--------main-------");   // 3、打印main
        LockSupport.unpark(/*线程名*/t1);   //4、叫醒t1，继续执行，打印t1---2
    }

    public static void testSync(){
        System.out.println(/*Thread.currentThread().getName()*/ "t1 -----1"); //1.首先打印t1 --1
        LockSupport.park();   //2.t1开始睡眠
        System.out.println("t1 ----- 2");


    }
}

伪代码如下：

volatile int status = 0;
Queue parkQueue; //集合 数组
void lock(){
    while(!compareAndSet(0,1)){
      park();
    }
    //lock    20s
    unpark();
}
void unlock(){
status = 0;
    lock_notify();
}
boolean compareAndSet(int except,int newValue){
    //compare  and  set操作,修改status成功返回true
}
void park(){
//将当前线程添加到等待队列
    parkQueue.add(currentThread)
  //将当前线程释放cpu，阻塞
  releaseCpu();
}
void lock_notify(){
//得到要唤醒的线程头部线程
    Thread t = parkQueue.header();
    //唤醒等待线程
    unpark(t);
}

更多详情

设置为vip可见的都可访问下面链接地址，即可观看原文
更多详情请访问： juntech