Java的各种锁介绍

1.公平锁和非公平锁

公平锁：是指多个线程按照申请锁的顺序申请锁，类似于排队打车，先来后到
非公平锁： 是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发情况下，有可能会造成优先级反转或者饥饿现象
并发包下的ReentrantLock可以通过构造函数指定是否是公平锁默认非公平锁

public ReentrantLock() {
    sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

二者区别
公平锁就是如其名公平，每个线程在获取锁的时候或首先查看此锁的维护等待队列，如果为空，或者当前线程是等待队列的第一个就占有锁，否则就会加入到等待队列中，以后按照FIFO的规则从队列中取到自己

非公平锁则不然，就是一上来就开始尝试占有，如果实在占有不了，再去按照公平锁的方式获取

2.可重入锁

可重入锁也叫递归锁
指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码
在同一线程在外层方法获得锁的时候，进入内层方法会自动获取锁
就是说线程可以进入任何一个它已经拥有的锁的所同步者的代码块

ReentrantLock和Synchronized都是典型的可重入锁
可重入锁最大的作用在于可以避免死锁

new Thread(new Thread() {
    @Override
    public void run() {
        synchronized (this) {
            System.out.println("第1次获取锁，这个锁是：" + this);
            int index = 1;
            while (true) {
                synchronized (this) {
                    System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this);
                }
                if (index == 5) {
                    break;
                }
            }
        }
    }
}).start();
/*
第1次获取锁，这个锁是：Thread[Thread-0,5,main]
第2次获取锁，这个锁是：Thread[Thread-0,5,main]
第3次获取锁，这个锁是：Thread[Thread-0,5,main]
第4次获取锁，这个锁是：Thread[Thread-0,5,main]
第5次获取锁，这个锁是：Thread[Thread-0,5,main]
* */

3.自旋锁

指尝试获取锁的线程不会立即阻塞，而是采取循环的方式去尝试获取锁，这样的好处减少线程上下文切换的消耗，缺点是循环会消耗CPU

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

4.读写锁

写锁也称为独占锁，指该锁一次只能有一个线程持有
ReentrantLock和Synchronized都是写锁
读锁也称为共享锁，该锁可以被多个线程所持有，读锁保证并发读取的高效
读写，写写，写读 的过程式互斥的

package lock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
class  Mycache{
    private volatile Map<String ,Object> map  =new HashMap<>();

    public void put(String key , Object value){
        System.out.println(Thread.currentThread().getName()+"正在写入"+key);
        try { TimeUnit.MILLISECONDS.sleep(300); }catch (Exception e){e.printStackTrace();}
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入完成");
    }
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"正在读取");
        try { TimeUnit.MILLISECONDS.sleep(300); }catch (Exception e){e.printStackTrace();}
        Object result = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取完成："+result);
    }
}
public class ReadWriteDemo {

    public static void main(String[] args) {
        Mycache mycache = new Mycache();
        for (int i = 0; i < 15; i++) {
            final  int temInt =i;
            new Thread(()->{
                mycache.put(temInt+"",temInt+"");
            },String.valueOf(i)).start();
        }
        for (int i = 0; i < 15; i++) {
            final  int temInt =i;
            new Thread(()->{
                mycache.get(temInt+"");
            },String.valueOf(i)).start();
        }


    }
}

如果不加lock

5.Lock和Synchronized的区别

角度	Lock	Synchronized
1.原始构成	是具体类(juc.Locks.lock)是api层面上的锁	是关键字属于JVM层面
2. 使用方式	Lock需要手动释放锁，如果没有则会出现死锁现象需要通过lock()，unlock()方法配合try语句块完成，lock()和unlock()方法一定是成对出现的	Synchronized 不需要手动去释放锁，一旦线程结束后，系统直接释放锁的占用
3.等待是否中断	ReetrantLock可以中断(1.设置超时方法trylock(long timeout,TimeUnit unit) 2.lockInterruptibly代码块中设置interrupt方法也可中断)	Synchronized不可中断，除非抛出异常
4.加锁是否公平	ReentrantLock二者都可以，可以设置通过构造方法	Synchronized是非公平锁
5.锁是否可以绑定多个Condition	ReetrantLock可以实现分组唤醒，可以实现精确唤醒，不会像Synchronized只能够随机唤醒一个或者全部唤醒	Synchronized不可以

角度2的代码关于Lock的

class Phone1 implements Runnable{
    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\t invoked sendMS()");
        sendEmail();
    }

    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\t invoked sendEmail()");

    }

    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        get();
    }
    public void get(){
        lock.lock();
        lock.lock();//不可以多加否则会一直等待
        try {
            System.out.println(Thread.currentThread().getName()+"\t invoked get()");
            set();
        }
         finally {
            lock.unlock();
            //lock.unlock();
        }
    }

    public void set(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t invoked set()");
        }
        finally {
            lock.unlock();
        }
    }
}

public class LockTest2 {
    public static void main(String[] args) {
        Phone1 phone = new Phone1();
        Thread t1 = new Thread(phone,"t1");
        Thread t2 = new Thread(phone,"t2");
        t1.start();
        t2.start();

    }
}
/*
t1  invoked get()
t1  invoked set()
*/
/*
正确输出：
t1  invoked get()
t1  invoked set()
t2  invoked get()
t2  invoked set()
*/

角度3的lock代码

package lock;

import java.util.concurrent.TimeUnit;

class HoldLockThread implements Runnable{

    private String lockA;
    private String lockB;

    public HoldLockThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"\t 自己持有"+lockA+"\t 尝试获得"+lockB);
            try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } }
        synchronized (lockB){
            System.out.println(Thread.currentThread().getName()+"\t 自己持有"+lockB+"\t 尝试获得"+lockA);
            try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } }

    }

}
public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new HoldLockThread(lockA,lockB),"ThreadAA" ).start();
        new Thread(new HoldLockThread(lockB,lockA),"ThreadBB" ).start();
    }
}
/*
ThreadAA  自己持有lockA  尝试获得lockB
ThreadBB  自己持有lockB  尝试获得lockA
(等待4s...)
ThreadBB  自己持有lockA  尝试获得lockB
ThreadAA  自己持有lockB  尝试获得lockA
*/