java_锁
1、公平锁和非公平锁
公平锁：是指多个线程按照申请锁的顺序来获取锁，类似于排队打饭，先来后到；
非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能或造成优先级反转或者饥饿的情况；
公平/非公平
在并发包ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或者非公平锁，默认是false：非公平锁；
公平锁：
在并发环境中，每个线程在获取锁时，会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，
否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己；
非公平锁：
线程会先尝试占有锁，尝试失败就再采用类似公平锁的方式；
synchronized：是非公平锁；
2、可重入锁（又名递归锁）
指的是同一线程外层函数获取锁之后，内层递归函数仍然能获取改锁的代码，
在同一个线程在外层获取锁的时候，在进入内层方法会自动获取锁；
也就是说：线程可以进入任何一个它已经拥有的锁所同步着的代码块；
ReentrantLock/synchronized就是典型的可重入锁，可重入锁最大的作用就是避免死锁；
synchronized可重入锁实现机制：
每个锁对象都拥有一个锁计数器和一个指向持有该锁的线程的指针；
当执行 monitorenterl时,如果目标锁对象的计数器为零,那么说明它没有被其他线程所持有,Java虚拟机会将该锁对象的持有线程设置为当前线程,并且将其计数器加1。
在目标锁对象的计数器不为零的情況下,如果锁对象的持有线程是当前线程,那么Java虚拟机可以将其计数器加1,否则需要等待,直至持有线程释放该锁。
当执行 monitorexit时,Java虚拟机则需将锁对象的计数器减1。计数器为零代表锁已被释放
可重入锁分类：
隐式锁：（即synchronized关键字使用的锁：默认是可重入锁）；
显式锁：即Lock、也有ReentrantLock这样的可重入锁；
synchronized可重入锁代码演示：
//可重入锁（也叫递归锁） public class ReenterLockDemo { public static void main(String[] args) { Phone phone = new Phone(); new Thread(() ->{ phone.sendSMS(); },"t1").start(); } } class Phone{ public synchronized void sendSMS(){ System.out.println(Thread.currentThread().getName()+"\t sendSMS()"); sendEmail(); } public synchronized void sendEmail(){ System.out.println(Thread.currentThread().getName()+"\t sendEmail()"); } }
ReentrantLock可重入锁代码演示：
public class ReenterLockDemo2{ public static void main(String[] args) { Phone2 phone = new Phone2(); Thread t1 = new Thread(phone,"t1"); t1.start(); } } class Phone2 implements Runnable{ Lock lock = new ReentrantLock(); @Override public void run() { get(); } public void get(){ lock.lock();//加锁 try { System.out.println(Thread.currentThread().getName()+"\t get()"); set(); }finally { lock.unlock();//解锁 } } public void set() { lock.lock(); try { System.out.println(Thread.currentThread().getName()+"\t set()"); }finally { lock.unlock(); } } }
3、自旋锁
指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，好处是减少上下文切换的消耗，缺点是循环会消耗CPU；
自旋锁代码验证：
/** * 自旋锁 * 好处：循环比较获取直到成功为止，没有类似wait的阻塞,减少线程上下文切换的消耗； * 坏处：会消耗CPU; * * 通过CAS操作完成自旋锁 * A线程先进来调用myLock方法自己持有锁5秒， * B随后进来发现当前线程持有锁，不是null，所以只能通过自选等待， * 直到A释放锁后B随后抢到； */ public class SpinLockDemo { //原子引用线程 AtomicReference<Thread> atomicReference = new AtomicReference<>(); public void myLock(){ Thread thread = Thread.currentThread(); System.out.println(Thread.currentThread().getName()+"\t myLock()"); while (!atomicReference.compareAndSet(null,thread)){ } } public void myUnLock(){ Thread thread = Thread.currentThread(); atomicReference.compareAndSet(thread,null); System.out.println(Thread.currentThread().getName()+"\t myUnLock()"); } public static void main(String[] args) { SpinLockDemo spinLockDemo = new SpinLockDemo(); //A线程进入后，占有锁5秒 new Thread(() ->{ spinLockDemo.myLock(); try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); } spinLockDemo.myUnLock(); },"A").start(); //此处main线程睡眠1秒，保证A线程先占有锁 try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(() ->{ spinLockDemo.myLock(); spinLockDemo.myUnLock(); },"B").start(); } }
4、独占锁（写锁）/共享锁（读锁）
独占锁：该锁一次只能被一个线程所持有，对ReentrantLock和Synchronized而言都是独占锁；
共享锁：该锁可被多个线程所持有，多ReentrantReadWriteLock而言，其读锁是共享锁，其写锁是独占锁；
读锁的共享锁可保证并发读，是非常高效的，读写、写读、写写的过程是互斥的；
示例代码：（未加锁）
/** * 多线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行； * 但是有一个线程想去写共享资源类，就不应该再有其它线程可以对该资源进行读和写； * 小总结： * 读、读 --->可以共存 * 读、写 --->不能共存 * 写、写 --->不能共存 * * 写操作：原子+独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断； */ class MyCache{//资源类 private volatile Map<String,Object> map = new HashMap<>(); public void put(String key,Object value){ System.out.println(Thread.currentThread().getName()+"\t 正在写入："+key); try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } map.put(key,value); System.out.println(Thread.currentThread().getName()+"\t 写入完成"); } public void get(String key){ System.out.println(Thread.currentThread().getName()+"\t 正在读取"); try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } Object value = map.get(key); System.out.println(Thread.currentThread().getName()+"\t 读取完成："+value); } } public class ReentrantReadWriteLockDemo { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 1; i <= 5; i++) { final int tempInt = i; new Thread(() ->{ myCache.put(tempInt+"",tempInt); },String.valueOf(i)).start(); } for (int i = 1; i <= 5; i++) { final int tempInt = i; new Thread(() ->{ myCache.get(tempInt+""); },String.valueOf(i)).start(); } } }
示例代码：（加锁）ReentrantReadWriteLock 写：独占锁，读：共享锁
class MyCache{//资源类 private volatile Map<String,Object> map = new HashMap<>(); private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); public void put(String key,Object value){ rwLock.writeLock().lock(); try { System.out.println(Thread.currentThread().getName()+"\t 正在写入："+key); try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } map.put(key,value); System.out.println(Thread.currentThread().getName()+"\t 写入完成"); }catch (Exception e){ e.printStackTrace(); }finally { rwLock.writeLock().unlock(); } } public void get(String key){ rwLock.readLock().lock(); try { System.out.println(Thread.currentThread().getName()+"\t 正在读取"); try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } Object value = map.get(key); System.out.println(Thread.currentThread().getName()+"\t 读取完成："+value); }catch (Exception e){ e.printStackTrace(); }finally { rwLock.readLock().unlock(); } } } public class ReentrantReadWriteLockDemo { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 1; i <= 5; i++) { final int tempInt = i; new Thread(() ->{ myCache.put(tempInt+"",tempInt); },String.valueOf(i)).start(); } for (int i = 1; i <= 5; i++) { final int tempInt = i; new Thread(() ->{ myCache.get(tempInt+""); },String.valueOf(i)).start(); } } }
5、死锁
代码示例：
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(1); } catch (InterruptedException e) { e.printStackTrace(); }
synchronized (lockB){//获取第二个参数
System.out.println(Thread.currentThread().getName()+"\t 自己持有："+lockB+"\t 尝试获得："+lockA);
}
}
}
}
public class DeadLockDemo {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
new Thread(new HoldLockThread(lockA,lockB),"A").start();
new Thread(new HoldLockThread(lockB,lockA),"B").start();
}
}
证明死锁：
