公平锁
是指多个线程按照申请锁的顺序来获取锁,类似排队打饭,先来后到。
非公平锁
是指多个线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程比先申请的线程优先获取锁。在高并发的情况下,有可能造成优先级反转或者饥饿现象。
公平锁和非公平锁区别
ReentrantLock默认是非公平锁,但是可以设置为true成为公平锁,Synchonized也是非公平锁。
可重入锁(递归锁)
指的是同一线程外层函数获得锁之后,内层递归函数仍然能获取该锁的代码,在同一线程在外层方法获取锁的时候,在进入内层方法会自动获取锁。
线程可以进入任何一个它已经拥有的锁所同步着的代码块。
最大作用:避免死锁
ReentrantLock和Synchonized都是可重入锁。
public class SynchronziedDemo {
private synchronized void print() {
doAdd();
}
private synchronized void doAdd() {
System.out.println("doAdd...");
}
public static void main(String[] args) {
SynchronziedDemo synchronziedDemo = new SynchronziedDemo();
synchronziedDemo.print(); // doAdd...
}
}
public class ReentrantLockDemo {
private Lock lock = new ReentrantLock();
private void print() {
lock.lock();
doAdd();
lock.unlock();
}
private void doAdd() {
lock.lock();
lock.lock();
System.out.println("doAdd...");
lock.unlock();
lock.unlock();
}
public static void main(String[] args) {
ReentrantLockDemo reentrantLockDemo = new ReentrantLockDemo();
reentrantLockDemo.print();
}
}
注意:Lock.lock();和Lock.unlock();个数匹配,多少个锁都可以正常运行,若是不匹配,则程序运行卡死。
自旋锁
指尝试获取锁的线程不会立即阻塞,而是采用循环的方式去尝试获取锁,好处是减少线程上下文切换的消耗,缺点是循环会消耗CPU。
手动实行自旋锁
public class SpinLock {
private AtomicReference<Thread> atomicReference = new AtomicReference<>();
private void lock () {
System.out.println(Thread.currentThread() + " coming...");
while (!atomicReference.compareAndSet(null, Thread.currentThread())) {
// loop
}
}
private void unlock() {
Thread thread = Thread.currentThread();
atomicReference.compareAndSet(thread, null);
System.out.println(thread + " unlock...");
}
public static void main(String[] args) throws InterruptedException {
SpinLock spinLock = new SpinLock();
new Thread(() -> {
spinLock.lock();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hahaha");
spinLock.unlock();
}).start();
Thread.sleep(1);
new Thread(() -> {
spinLock.lock();
System.out.println("hehehe");
spinLock.unlock();
}).start();
}
}