ReentrantLock基本使用与原理

ReentrantLock基本使用

package com.study.lock;

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

public class Demo1_GetLock {
    //公平锁
    //static Lock lock = new ReentrantLock(true);

    //非公平锁
    static Lock lock = new ReentrantLock();

    public static void main(String args[]) throws InterruptedException {
        //主线程 拿到锁
        lock.lock();

        Thread th =  new Thread(new Runnable() {
            @Override
            public void run() {
 /*               System.out.println("begain to get lock...");
                lock.lock();
                System.out.println("interrupted...");*/

                //子线程 获取锁(浅尝辄止)
/*                boolean result = lock.tryLock();
                System.out.println("是否获得到锁：" +result);*/

                //子线程 获取锁(点到为止)
/*                try {
                    boolean result1 = lock.tryLock(5, TimeUnit.SECONDS);
                    System.out.println("是否获得到锁：" +result1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/

                //子线程 获取锁（任人摆布）
           /*     try {
                    System.out.println("start to get lock Interruptibly");
                    lock.lockInterruptibly();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("dad asked me to stop...");
                }*/

                //子线程 获取锁（不死不休）
                System.out.println("begain to get lock...");
                lock.lock();
                System.out.println("succeed to get lock...");

            }
        });
        th.start();

        Thread.sleep(10000L);
        lock.unlock();


    }

}

 

使用Condition进行线程通信，如同wait、notify一般也只能在加锁的代码中使用

package com.study.lock;

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

public class Demo3_Condition {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Thread th = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                System.out.println("condition.await()");
                try {
                    condition.await();
                    System.out.println("here i am...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        });

        th.start();


        Thread.sleep(2000L);
        lock.lock();

        condition.signalAll();

        lock.unlock();

    }

}

Condition死锁情况，和wait、notify一样对代码执行的先后顺序有要求，不能在我还没有锁时就已经signal释放了锁，然后再去加锁，这个时候没有人回去释放锁了

 

package com.study.lock;

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

public class Demo3_Condition_deadLock {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {

        Thread th = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                try {
                    System.out.println("获得锁，调用condition.await()\n");
                    condition.await();      // waiting  park
                    System.out.println("唤醒了...\n");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });

        th.start();
//        Thread.sleep(2000L);
        lock.lock();
        condition.signal();
        lock.unlock();
    }
}

 

ReentrantLock手写阻塞队列

package com.study.lock;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo4_Condition3 {
    public static void main(String args[]) throws InterruptedException {
        JamesQueue bb = new JamesQueue(5);

        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    bb.put("x" + i);
                }
            }
        }.start();

        Thread.sleep(3000L);
        System.out.println("开始从队列中取元素...");
        for (int i = 0; i < 10; i++) {
            bb.take();
            Thread.sleep(3000L);
        }
    }
}


/*
  1、自己实现一个阻塞队列，只能存储  n个元素
   put时，若队列未满，直接put，
         若队列满，就阻塞，直到再有空间
   get时，若队列中有元素，则获取到元素
         若无元素，则等待元素
 */


class JamesQueue{
    List<Object> list = new ArrayList<>();

    Lock lock = new ReentrantLock();
    Condition putCondition = lock.newCondition();
    Condition takeCondition = lock.newCondition();

    private int length;

    public JamesQueue(int length){
        this.length = length;
    }

    public void put(Object obj){
        lock.lock();
        try {
            if (list.size() < length){
                list.add(obj);
                System.out.println("put:" + obj);
                takeCondition.signal();
            }else{
                putCondition.await();
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public Object take(){
        lock.lock();
        Object obj = null;
        try {
            for (;;) {
                if (list.size() > 0) {
                    obj = list.get(0);
                    list.remove(0);
                    System.out.println("take：" + obj);

                    putCondition.signal();
                    break;
                } else {
                    takeCondition.await();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
        return obj;
    }
}

ReentrantLock原理

 

他底层维护了一个 owner=当前线程   , count 是 当前重入次数，每次加锁成功加1，释放减1

 

他是如何加锁的呢，先去判断count 是否为0 ，为0表示当前没有线程占用，如何去用CAS机制去操作修改成1 ， 修改成功，在去修改owner为自己，注意这个owner不是CAS修改只是一个普通set，因为，在没有线程修改成功count，是没有线程会来修改，owner的。

抢锁，他会去判断count是否为0，如果不为0，他会去判断owner是否是自己，是自己，count值加1（这次修改不需要CAS）代表重入成功，不是自己进入waiters等待队列，然后挂起block状态

解锁，假如当前的owner是其他线程，不是自己会报错，如果owner是自己，count就去减1，直到减到为0，减到为0就会把owner修改为null再去唤醒，等待队列中的头部线程

手写ReenteantLock

package com.study.lock;


import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;

public class JamesLock implements Lock {

    //锁的拥有者
    AtomicReference<Thread> owner = new AtomicReference<>();

    //等待队列
    private LinkedBlockingQueue<Thread> waiter = new LinkedBlockingQueue<>();




    @Override
    public boolean tryLock() {
        return owner.compareAndSet(null, Thread.currentThread());
    }

    @Override
    public void lock() {
        if (!tryLock()){
            waiter.offer(Thread.currentThread());

            for(;;){
                Thread head = waiter.peek();
                if (head == Thread.currentThread()){
                    if(!tryLock()){
                        //挂起线程
                        LockSupport.park();
                    }else{
                        //抢锁成功，将线程出度列
                        waiter.poll();
                        return;
                    }
                }else{
                    //线程挂起
                    LockSupport.park();
                }
            }
        }
    }

    @Override
    public void unlock() {
        if (tryUnlock()){
            Thread th = waiter.peek();
            if (th !=null){
                LockSupport.unpark(th);
            }
        }
    }

    public boolean tryUnlock(){
        //首先判断当前线程是否站有锁
        if (owner.get() !=Thread.currentThread()){
            throw new IllegalMonitorStateException();
        }else{
            return owner.compareAndSet(Thread.currentThread(), null);
        }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }



    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }



    @Override
    public Condition newCondition() {
        return null;
    }
}