1. 死锁 1.1 定义 死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。
1.2 产生死锁的必要条件
互斥条件:指进程对所分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源,则请求者只能等待,直至占有资源的进程用毕释放。
请求和保持条件:指进程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求进程阻塞,但又对自己已获得的其它资源保持不放。
不剥夺条件:指进程已获得的资源,在未使用完之前,不能被剥夺,只能在使用完时由自己释放。
环路等待条件:指在发生死锁时,必然存在一个进程——资源的环形链,即进程集合{P0,P1,P2,···,Pn}中的P0正在等待一个P1占用的资源;P1正在等待P2占用的资源,……,Pn正在等待已被P0占用的资源。
1.3 如何解决死锁 知道死锁发生的原因,解决死锁的方法也有四种:
打破互斥条件:改造独占性资源为虚拟资源,大部分资源已无法改造。
打破不可抢占条件:当一进程占有一独占性资源后又申请一独占性资源而无法满足,则退出原占有的资源。
打破占有且申请条件:采用资源预先分配策略,即进程运行前申请全部资源,满足则运行,不然就等待,这样就不会占有且申请。
打破循环等待条件:实现资源有序分配策略,对所有设备实现分类编号,所有进程只能采用按序号递增的形式申请资源。
避免死锁常见的算法有有序资源分配法、银行家算法 。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 synchronized (lock1) { synchronized (lock2) { } } synchronized (lock2) { synchronized (lock1) { } }
具体手段 :(1) 内部确认拿锁顺序,修改拿锁和释放锁顺序;(2) 采用尝试拿锁的机制
1 2 3 4 5 6 7 8 9 10 11 12 13 14 synchronized (lock1) { synchronized (lock2) { } } synchronized (lock1) { synchronized (lock2) { } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 public class TryLock { private static Lock No13 = new ReentrantLock(); private static Lock No14 = new ReentrantLock(); private static void fisrtToSecond () throws InterruptedException { String threadName = Thread.currentThread().getName(); Random r = new Random(); while (true ) { if (No13.tryLock()) { System.out.println(threadName + " get 13" ); try { if (No14.tryLock()) { try { System.out.println(threadName + " get 14" ); System.out.println("fisrtToSecond do work------------" ); break ; } finally { No14.unlock(); } } } finally { No13.unlock(); } } } } private static void SecondToFisrt () throws InterruptedException { String threadName = Thread.currentThread().getName(); Random r = new Random(); while (true ) { if (No14.tryLock()) { System.out.println(threadName + " get 14" ); try { if (No13.tryLock()) { try { System.out.println(threadName + " get 13" ); System.out.println("SecondToFisrt do work------------" ); break ; } finally { No13.unlock(); } } } finally { No14.unlock(); } } } } private static class TestThread extends Thread { private String name; public TestThread (String name) { this .name = name; } public void run () { Thread.currentThread().setName(name); try { SecondToFisrt(); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main (String[] args) { Thread.currentThread().setName("TestDeadLock" ); TestThread testThread = new TestThread("SubTestThread" ); testThread.start(); try { fisrtToSecond(); } catch (InterruptedException e) { e.printStackTrace(); } } }
1.4 死锁的危害
线程不工作了,但是整个程序还是活着的
没有任何的异常信息可以供我们检查。
一旦程序发生了发生了死锁,是没有任何的办法恢复的,只能重启程序。
自身程序死锁了,还可能导致其他程序拿不到资源,导致其他程序crash。
2.活锁 两个线程在尝试拿锁的机制中,发生多个线程之间互相谦让,不断发生同一个线程总是拿到同一把锁,在尝试拿另一把锁时因为拿不到,而将本来已经持有的锁释放的过程。
线程A B 锁1,2
拿锁顺序
A(1)<2>–(1)<2>–(1)<2>–(1)<2>–(1)<2>–(1)<2>
B(2)<1>–(2)<1>–(2)<1>–(2)<1>–(2)<1>–(2)<1>
以上现象会拉长拿锁周期,因为A拿到锁1,尝试拿锁2,但是拿不到锁2。B线程先拿到锁2,尝试拿锁1。就会导致活锁现象,线程也没有死,但是不能执行期望的代码。
解决办法:每个线程休眠随机数,错开拿锁的时间。
3.线程饥饿 低优先级的线程,总是拿不到执行时间片。
4.前面《多线程并发总结录》中已经总结过Synchronized和ThreadLocal实现多线程安全。下面来总结一下CAS。在阐述CAS之前,需要先谈谈原子操作相关知识点。下面我们就开始吧。 下面从what,how,why三个方面来引出CAS。
4. 1什么是原子操作? 有两个任务A,B,每个任务需要很多步骤执行;但是对于每个线程来说,要么任务执行并且执行完成,要么不执行。这样的操作就叫原子操作。
4.2 如何实现原子操作? 实现原子操作可以使用锁,锁机制就可以满足基本需求了,但是有的时候我们的需求并非这么简单,我们需要更有效,更加灵活的机制,synchronized关键字是基于阻塞的锁机制,也就是说当一个线程拥有锁的时候,访问同一资源的其它线程需要等待,直到该线程释放锁。
使用synchronized来实现会有以下几个问题:
被阻塞的线程优先级很高很重要,可能会导致低优先级线程饥饿。
持锁线程一直不释放锁,可能会导致其他线程拿不到锁,一直无法执行(之前项目联调阶段遇到语音助理一直拿着音频焦点不释放,导致其他应用请求焦点一直拿不到焦点)
存在死锁的可能性
上下文切换比较耗时,对于简单的原子操作有些不划算
基于以上使用synchronized来实现原子操作的缺点,CAS就应运而生了。
4.3 CAS是什么? CAS(Compare and Swap) ,通俗地讲:如果某个地址上的值和期望的值相等,则给其赋予新值,否则不做任何事儿。
每一个CAS操作过程都包含三个运算符:一个内存地址V,一个期望的值A和一个新值B,操作的时候如果这个地址上存放的值等于这个期望的值A,则将地址上的值赋为新值B,否则不做任何操作。
1 2 3 4 5 6 7 8 9 10 public class AtomicIntegerTest { private static AtomicInteger ai = new AtomicInteger(100 ); public static void main (String[] args) { System.out.println(ai.getAndIncrement()); System.out.println(ai.incrementAndGet()); System.out.println(ai.addAndGet(20 )); } }
4.4 CAS实现原子操作的三大问题 4.4.1 ABA问题 因为CAS需要在操作值的时候,检查值有没有发生变化,如果没有发生变化则更新,但是如果一个值原来是A,变成了B,又变成了A,那么使用CAS进行检查时会发现它的值没有发生变化,但是实际上却变化了。
解决方案:在变量前面追加上版本号,每次变量更新的时候把版本号加1,那么A→B→A就会变成1A→2B→3A。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 public class UseAtomicStampedReference { static AtomicStampedReference<String> asr = new AtomicStampedReference("Jack" , 0 ); public static void main (String[] args) throws InterruptedException { final int oldStamp = asr.getStamp(); final String oldReference = asr.getReference(); System.out.println(oldReference + "current stamp -->" + oldStamp); Thread rightStampThread = new Thread(new Runnable() { @Override public void run () { System.out.println(Thread.currentThread().getName() + ":当前变量值:" + oldReference + "-当前版本戳:" + oldStamp + "-" + asr.compareAndSet(oldReference, oldReference + "+Java" , oldStamp, oldStamp + 1 )); } }); Thread errorStampThread = new Thread(new Runnable() { @Override public void run () { String reference = asr.getReference(); System.out.println(Thread.currentThread().getName() + ":当前变量值:" + reference + "-当前版本戳:" + asr.getStamp() + "-" + asr.compareAndSet(reference, reference + " + Java" , oldStamp, oldStamp + 1 )); } }); rightStampThread.start(); rightStampThread.join(); errorStampThread.start(); errorStampThread.join(); System.out.println(asr.getReference() + "current stamp -->" + asr.getStamp()); } }
AtomicStampedReference和AtomicMarkableReference区别
相同点都是为了解决CAS原子操作中给每次修改做标记。
不同点是AtomicStampedReference有版本管理的概念,每次操作之后,给stamp值加1;而AtomicMarkableReference只是在每次修改之后,把mark标志位置位。
4.4.2 循环时间长开销大 自旋CAS如果长时间不成功,会给CPU带来非常大的执行开销。
4.4.3只能保证一个共享变量的原子操作。 当对一个共享变量执行操作时,我们可以使用循环CAS的方式来保证原子操作,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁。
还有一个取巧的办法,就是把多个共享变量合并成一个共享变量来操作。比如,有两个共享变量i=2,j=a,合并一下ij=2a,然后用CAS来操作ij。从Java 1.5开始,JDK提供了AtomicReference类来保证引用对象之间的原子性,就可以把多个变量放在一个对象里来进行CAS操作。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 public class UseAtomicReference { static AtomicReference<UserInfo> atomicUserRef; public static void main (String[] args) { UserInfo user = new UserInfo("DY" , 10 ); atomicUserRef = new AtomicReference(user); UserInfo updateUser = new UserInfo("Jack" ,18 ); atomicUserRef.compareAndSet(user,updateUser); System.out.println(atomicUserRef.get()); System.out.println(user); } static class UserInfo { private volatile String name; private int age; public UserInfo (String name, int age) { this .name = name; this .age = age; } public String getName () { return name; } public int getAge () { return age; } } }
4.5 悲观锁和乐观锁 synchronized属于悲观锁:
始终感觉有“贼”想谋害朕,一拿到时间片就想办法去抢“锁”
CAS属于乐观锁:
每次尝试去修改,一次不行下次再来,知道修改成功为止。
测试用例代码见: git@github.com :oujie123/UnderstandingOfThread.git