java 锁的学习

java 锁的学习

---

java锁的种类以及介绍

java的锁的种类主要有自旋锁、阻塞锁、可重入锁、读写锁、悲观锁、乐观锁。
主要介绍下自旋锁、阻塞锁、可重入锁。

• 
  
• 自旋锁
  

自旋锁是让当前线程不停地的在循环体内执行实现的，当循环的条件被其他线程改变时 才能进入临界区。

public class SpinLock {  
    AtomicReference<Thread> owner = new AtomicReference<Thread>();//持有自旋锁的线程对象 
    private int count =0;   
    public void lock() {  
        Thread cur = Thread.currentThread();  
        if (cur == owner.get()) {  
            count++;
            //如果不是线程本身，已经获取锁，不需要再次获取,记录获取锁的次数  
            return;  
        }   
        while (!owner.compareAndSet(null, cur)) { 
            //循环获取锁
        }  
    }  

    public void unLock() {  
        Thread cur = Thread.currentThread();  
        if (cur == owner.get()) {  
            if (count > 0) {  
                count--;  
            } else {  
                owner.compareAndSet(cur, null);  
            }  
        }  
    }  

注意：
1：自旋锁基于循环执行获取锁，等待的时候，并不释放cpu时间片，相比synchronized wait()操作，减小了释放，重新获取的消耗。
2：通过上面的实现可以知道，线程的竞争锁比较激烈的情况下，会严重的影响机器性能，故自旋锁使用于竞争小的情况下。

• 
  
• 阻塞锁
  

阻塞锁，可以说是让线程进入阻塞状态进行等待，当获得相应的信号（唤醒，时间） 时，才可以进入线程的准备就绪状态，准备就绪状态的所有线程，通过竞争，进入运行状态

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import java.util.concurrent.locks.LockSupport;

public class Lock {
    public static class Node {
        private volatile Thread isLocked;
    }
    private volatile Node tail;
    private static final ThreadLocal<Node> LOCAL   = new ThreadLocal<Node>();
    private static final AtomicReferenceFieldUpdater<Lock, Node> UPDATER =AtomicReferenceFieldUpdater.newUpdater(Lock.class,                                                                                  Node.class, "tail");
    public void lock() {
        Node node = new Node();
        LOCAL.set(node);
        Node preNode = UPDATER.getAndSet(this, node);
        if (preNode != null) {
            preNode.isLocked = Thread.currentThread();
            LockSupport.park(this);
            preNode = null;
            LOCAL.set(node);
        }
    }
    public void unlock() {
        Node node = LOCAL.get();
        if (!UPDATER.compareAndSet(this, node, null)) {
            LockSupport.unpark(node.isLocked);
        }
        node = null;
    }
 ｝

注意：
阻塞锁的优势在于，阻塞的线程不会占用cpu时间， 不会导致 CPu占用率过高，但进入时间以及恢复时间都要比自旋锁略慢。

• 可重入锁

  可重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。
  可重入锁最大的作用是避免死锁

• 读写锁

  读写锁主要原理基于阻塞锁实现的。阻塞锁很优雅的控制了竞争资源的安全访问。但是这种锁不区分读写，有些场景对竞争资源的读比较多，写的比较少，为了解决这中问题和提高性能，读写锁就解决了改问题，在读的地方使用读锁，在写的地方使用写锁，灵活控制，如果没有写锁的情况下，读是无阻塞的,在一定程度上提高了程序的执行效率。
  读写锁的原理：
  1：存在读锁的情况下，其他写不可用，其他读不阻塞。
  2：存在写锁的情况下，其他线程读写都不用

• 乐观锁&悲观锁

  悲观锁，就是不管是否发生多线程冲突，只要存在这种可能，就每次访问都加锁，对所有共享资源的都加锁。
  乐观锁，就是通过标记值控制（或者版本），每次操作前通过标记值判断是否是最新内容，最新内容就可以操作，不是最新的就继续循环判断标记值，直到是最新类容
  悲观锁和乐观锁场景与数据库的一些操作中。