Java 锁

Java锁

1、公平锁非公平锁

公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到。

非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象。

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

两者区别

并发包中的ReentranLock的创建可以指定构造函数的 boolean类型来得到公平锁或者非公平锁，默认是非公平锁（false）！

公平锁：就是很公平，在并发环境中，每个线程在获取到锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己。

非公平锁：非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就会采用类似公平锁那种方式。

Java ReentranLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

对于Synchronized而言，也是一种非公平锁。

2、可重入锁

是什么

可重入锁（也叫递归锁），指的是同一线程外层函数获得锁之后，内层函数仍然能获得该锁的代码，在同一个线程的外层方法获得锁的时候，在进入内层方法会自动获取锁。

也就是说，线程可以进入任何一个他已经拥有的锁，所同步着的代码块。好比家里进入大门之后，就可以进入里面的房间了；

ReentranLock、Synchronized就是一种典型的可重入锁；

可重入锁最大的作用就是避免死锁

测试一：Synchronized

public class fairLockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendSMS();
        }).start();

        new Thread(() -> {
            phone.sendSMS();
        }).start();
    }
}
class Phone{
    public synchronized void sendSMS(){
        System.out.println(Thread.currentThread().getName() + "sendSMS");
        sendEmil();
    }
    private synchronized void sendEmil() {
        System.out.println(Thread.currentThread().getName() + "sendEmil");
    }
}

测试二：ReentranLock

public class ReentranLockDemo {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        new Thread(phone1, "T1").start();
        new Thread(phone1, "T2").start();
    }
}
class Phone1 implements Runnable {
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        get();
    }
    private void get() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "get()");
            set();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    private void set() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "set()");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

3、自旋锁（spinlock）

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

unsafe.getAndAddInt()
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、死锁

死锁是什么

死锁是指两个或者两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉那他们都将无法推进下去，如果系统资源充足，进程的资源请求都能满足，死锁出现的可能性就很低，否则就会因为争夺有限的资源而陷入死锁。

产生死锁主要原因：

1、系统资源不足

2、进程运行推进的顺序不合适

3、资源分配不当

测试

public class deadlockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new HoldLockThread(lockA, lockB), "T1").start();
        new Thread(new HoldLockThread(lockB, lockA), "T2").start();
    }
}
class HoldLockThread implements Runnable {
    public HoldLockThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }
    private String lockA;
    private String lockB;
    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "lock:" + lockA + "=>get" + lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "lock:" + lockB + "=>get" + lockA);
            }
        }
    }
}

解决

1、使用jps -l命令定位进程号

2、使用jstack 进程号找到死锁查看