Lock的简单介绍

Lock

索引

Lock 是 java.util.concurrent.locks包下的一个接口 ，包含了lock() 方法和unlock()方法等,lock() 用于获取锁资源,而unlock()用于释放锁资源。下面讲一下他的一些实现类。

ReentrantLock

ReentrantLock 实现了Lock接口，是一种可重入锁。可重入锁可以理解为一种锁的标识。初始标识为0，表示当前锁没有被任何线程锁拥有，当一个线程获取了所资源时，标记+1，当线程释放所资源时标识-1。可以参考一下。和synchronized区别就是这个需要手动释放锁资源。

/**
 * @author dks
 * @date 2019/7/13 13:30
 */
public class MyReentrantLock {

        private ArrayList<Integer> arrayList = new ArrayList<Integer>();
        private Lock lock = new ReentrantLock();    //注意这个地方，声明为类的属性
        public static void main(String[] args)  {
            final MyReentrantLock test = new MyReentrantLock();

            new Thread(){
                public void run() {
                    test.insert(Thread.currentThread());
                };
            }.start();
            //可以用Java箭头函数特性改写上述冗余代码：
            // new Thread(){()->Thread.currentThread}.start();
            new Thread(){
                public void run() {
                    test.insert(Thread.currentThread());
                };
            }.start();
        }

        public void insert(Thread thread) {
            lock.lock();
            try {
                System.out.println(thread.getName()+"得到了锁");
                for(int i=0;i<5;i++) {
                    arrayList.add(i);
                }
            } catch (Exception e) {
                // TODO: handle exception
            }finally {
                //System.out.println(thread.getName()+"释放了锁");
                lock.unlock();
            }
        }
}

ReentrantReadWriteLock

ReentrantReadWriteLock是一个读写锁，实现了ReadWriteLock接口
ReenTrantReadWriteLock有两个成员比阿娘
private final ReentrantReadWriteLock.ReadLock readerLock; //读锁
/** Inner class providing writelock */
private final ReentrantReadWriteLock.WriteLock writerLock; //写锁
多个读锁不互斥，读锁和写锁互斥 如果你的代码只读数据，可以多个人同时读数据，那么就加读锁，如果你的代码需要修改数据，只能一个人修改，不能多个人同时修改，那就加写锁。all in all，写操作就加写锁，读操作就加读锁。可以看一下简单的代码。

/**
* @author dks
* @date 2019/7/19 20:02
*/
public class ReentrantWriteReadLockTest {

 public static void main(String[] args) {

     MyList myList = new MyList();
     for (int i = 0; i < 10; i++) {
         new Thread(){
             @Override
             public void run() {
                 myList.get();
             }
         }.start();
     }

 }

}

//定义一个类作为容器
class MyList{

 private List<Object> list = new ArrayList<>(); // 作为共享资源
 private ReentrantReadWriteLock rrw = new ReentrantReadWriteLock(); //读写锁

 //用于读数据
 public List<Object> get(){

     rrw.readLock().lock(); // 设置读锁， 不允许其他线程写操作只允许读
     System.out.println(Thread.currentThread().getName()+" :只允许读");
     try {
         Thread.sleep(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }finally {
         rrw.readLock().unlock(); // 释放锁资源
     }
     return null;
 }

 // 用于写数据
 public void put(Object obj){

     rrw.writeLock().lock(); //设置写锁， 不允许其他线程读也不允许写。
     System.out.println(Thread.currentThread().getName()+" :既不允许读，也不允许写");
     try {
         Thread.sleep(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }finally {
         rrw.writeLock().unlock();//释放锁资源
     }
 }

}

总结

这个东西面试的时候问的挺多的，感觉有理解不到很深的地步。先从基础做起吧。