java多线程学习之死锁的模拟和避免(实例讲解)

1.死锁 死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。 Java 死锁产生的四个必要条件： 1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用 2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。 3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。 4、循环等待，即存在 0 Comments

1.死锁

死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

Java 死锁产生的四个必要条件：

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

2.模拟一个死锁

java" id="highlighter_613316">

?

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

package com.tl.skyLine.thread;

import java.util.Date;

/**

* Created by tl on 17/3/3.

*/

public class DeadLock {

public static String bowl = "碗";

public static String chopsticks = "筷子";

public static void main(String[] args) {

LockA la = new LockA();

new Thread(la).start();

LockB lb = new LockB();

new Thread(lb).start();

}

}

class LockA implements Runnable {

public void run() {

try {

System.out.println(new Date().toString() + "邹保健开始拿餐具吃饭");

while (true) {

synchronized (DeadLock.bowl) {

System.out.println(new Date().toString() + "邹保健抢到了碗");

Thread.sleep(3000); // 此处等待是给B能锁住机会

synchronized (DeadLock.chopsticks) {

System.out.println(new Date().toString() + "邹保健抢到了筷子");

Thread.sleep(60 * 1000); // 为测试，占用了就不放

}

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

class LockB implements Runnable {

public void run() {

try {

System.out.println(new Date().toString() + "陈顶天开始拿餐具吃饭");

while (true) {

synchronized (DeadLock.chopsticks) {

System.out.println(new Date().toString() + "陈顶天抢到了筷子");

Thread.sleep(3000); // 此处等待是给A能锁住机会

synchronized (DeadLock.bowl) {

System.out.println(new Date().toString() + "陈顶天抢到了碗");

Thread.sleep(60 * 1000); // 为测试，占用了就不放

}

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

结果：

?

1

2

3

4

Fri Mar 03 16:34:36 CST 2017陈顶天开始拿餐具吃饭

Fri Mar 03 16:34:37 CST 2017陈顶天抢到了筷子

Fri Mar 03 16:34:36 CST 2017邹保健开始拿餐具吃饭

Fri Mar 03 16:34:37 CST 2017邹保健抢到了碗

结果陈顶天同学抢到了参筷子，拿着不放，邹保健同学抢到了碗，也死活不放手，但是只有一双筷子和一双碗，结果就是双双饿死。。。

3.避免死锁

假如我们是陈顶天和邹保健同学的同事，肯定不忍心看到他们饿死，那么怎么办呢？

我们就要采取方法避免思索的发生，这边介绍两种方法，一种是加锁顺序（线程按照一定的顺序加锁）；另一种是加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）；

3.1 加锁顺序

当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生。我们上面的代码为了模拟死锁，将线程LockA与LockB两位同事的抢夺资源顺序做了一个调整，LockA先抢碗，然后sleep3秒，LockB先抢筷子，我们现在把争夺资源顺序改一下，两个线程都是先抢碗，再抢筷子，严格按照这个顺序运行，那么A抢到碗以后，B去争夺资源，必须从抢碗开始，不能在抢不到碗的情况下去抢筷子，这样就避免死锁的发生，这也是避免死锁最简单的方法。

代码修改如下：

?

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

/**

* Created by tl on 17/3/3.

*/

public class UnDeadLock {

public static String bowl = "碗";

public static String chopsticks = "筷子";

public static void main(String[] args) {

LockA la = new LockA();

new Thread(la).start();

LockB lb = new LockB();

new Thread(lb).start();

}

}

class LockA implements Runnable {

public void run() {

try {

System.out.println(new Date().toString() + "邹保健开始拿餐具吃饭");

while (true) {

synchronized (UnDeadLock.bowl) {

System.out.println(new Date().toString() + "邹保健抢到了碗");

synchronized (UnDeadLock.chopsticks) {

System.out.println(new Date().toString() + "邹保健抢到了筷子");

}

}

Thread.sleep(5000);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

class LockB implements Runnable {

public void run() {

try {

System.out.println(new Date().toString() + "陈顶天开始拿餐具吃饭");

while (true) {

synchronized (UnDeadLock.bowl) {

System.out.println(new Date().toString() + "陈顶天抢到了碗");

synchronized (UnDeadLock.chopsticks) {

System.out.println(new Date().toString() + "陈顶天抢到了筷子");

}

}

Thread.sleep(5000);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

此时运行结果

?

1

2

3

4

5

6

7

8

9

10

11

12

Fri Mar 24 11:16:51 CST 2017邹保健开始拿餐具吃饭

Fri Mar 24 11:16:51 CST 2017陈顶天开始拿餐具吃饭

Fri Mar 24 11:16:51 CST 2017邹保健抢到了碗

Fri Mar 24 11:16:51 CST 2017邹保健抢到了筷子

Fri Mar 24 11:16:51 CST 2017陈顶天抢到了碗

Fri Mar 24 11:16:51 CST 2017陈顶天抢到了筷子

Fri Mar 24 11:16:56 CST 2017邹保健抢到了碗

Fri Mar 24 11:16:56 CST 2017邹保健抢到了筷子

Fri Mar 24 11:16:56 CST 2017陈顶天抢到了碗

Fri Mar 24 11:16:56 CST 2017陈顶天抢到了筷子

Fri Mar 24 11:17:01 CST 2017邹保健抢到了碗

Fri Mar 24 11:17:01 CST 2017邹保健抢到了筷子

就不会再出现死锁的情况了。

3.2 加锁时效

加锁时效的原理就是：给每一个访问线程增加访问时效，若一个线程没有在给定的时限内成功获得所有需要的锁，则会进行回退并释放所有已经获得的锁（此时就打破了造成死锁的四个原因中的第三个原因），然后等待一段随机的时间再重试。

为了实现这个目标，我们不使用显示的去锁，我而是用信号量Semaphore去控制。信号量可以控制资源能被多少线程访问，这里我们指定只能被一个线程访问，就做到了类似锁住。而信号量可以指定去获取的超时时间，我们可以根据这个超时时间，去做一个额外处理。对于无法成功获取的情况，一般就是重复尝试，或指定尝试的次数，也可以马上退出。

?

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

package com.tl.skyLine.thread;

import java.util.Date;

import java.util.concurrent.Semaphore;

import java.util.concurrent.TimeUnit;

/**

* Created by tl on 17/3/3.

*/

public class UnDeadLock {

public static String bowl = "碗";

//信号量可以碗只能能被一个线程同时访问

public static final Semaphore a1 = new Semaphore(1);

public static String chopsticks = "筷子";

//信号量可以筷子只能能被一个线程同时访问

public static final Semaphore a2 = new Semaphore(1);

public static void main(String[] args) {

LockAa la = new LockAa();

new Thread(la).start();

LockBa lb = new LockBa();

new Thread(lb).start();

}

}

class LockAa implements Runnable {

public void run() {

try {

System.out.println(new Date().toString() + "邹保健开始拿餐具吃饭");

while (true) {

if (UnDeadLock.a1.tryAcquire(1, TimeUnit.SECONDS)) {

System.out.println(new Date().toString() + "邹保健抢到了碗");

if (UnDeadLock.a2.tryAcquire(1, TimeUnit.SECONDS)) {

System.out.println(new Date().toString() + "邹保健抢到了筷子,凑齐了餐具,准备吃饭");

Thread.sleep(60 * 1000 * 10); // 抢到餐具就开始吃饭,吃饭时间十分钟

} else {

System.out.println(new Date().toString() + "筷子已经被抢走了,邹保健抢筷子失败");

}

} else {

System.out.println(new Date().toString() + "碗已经被抢走了,邹保健抢碗失败");

}

UnDeadLock.a1.release(); // 释放

UnDeadLock.a2.release();

System.out.println(new Date().toString() + "邹保健把抢到的部分餐具又放回原处");

Thread.sleep(1000); // 马上进行尝试，现实情况下do something是不确定的

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

class LockBa implements Runnable {

public void run() {

try {

System.out.println(new Date().toString() + "陈顶天开始拿餐具吃饭");

while (true) {

if (UnDeadLock.a2.tryAcquire(1, TimeUnit.SECONDS)) {

System.out.println(new Date().toString() + "陈顶天抢到了筷子");

if (UnDeadLock.a1.tryAcquire(1, TimeUnit.SECONDS)) {

System.out.println(new Date().toString() + "陈顶天抢到了碗,凑齐了餐具,准备吃饭");

Thread.sleep(60 * 1000 * 10); // 抢到餐具就开始吃饭,吃饭时间十分钟

} else {

System.out.println(new Date().toString() + "碗已经被抢走了,陈顶天抢碗失败");

}

} else {

System.out.println(new Date().toString() + "筷子已经被抢走了,陈顶天抢筷子失败");

}

UnDeadLock.a1.release(); // 释放

UnDeadLock.a2.release();

System.out.println(new Date().toString() + "陈顶天把抢到的部分餐具又放回原处");

Thread.sleep(10 * 1000);//这里只是为了演示，所以tryAcquire只用1秒，而且B要给A让出能执行的时间，否则两个永远是死锁

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

结果

?

1

2

3

4

5

6

7

8

9

10

11

Fri Mar 03 18:12:07 CST 2017邹保健开始拿餐具吃饭

Fri Mar 03 18:12:07 CST 2017陈顶天开始拿餐具吃饭

Fri Mar 03 18:12:07 CST 2017邹保健抢到了碗

Fri Mar 03 18:12:07 CST 2017陈顶天抢到了筷子

Fri Mar 03 18:12:08 CST 2017筷子已经被抢走了,邹保健抢筷子失败

Fri Mar 03 18:12:08 CST 2017邹保健把抢到的部分餐具又放回原处

Fri Mar 03 18:12:08 CST 2017陈顶天抢到了碗,凑齐了餐具,准备吃饭

Fri Mar 03 18:12:10 CST 2017碗已经被抢走了,邹保健抢碗失败

Fri Mar 03 18:12:10 CST 2017邹保健把抢到的部分餐具又放回原处

Fri Mar 03 18:12:11 CST 2017邹保健抢到了碗

Fri Mar 03 18:12:11 CST 2017邹保健抢到了筷子,凑齐了餐具,准备吃饭

很明显看到，我们打破了满足死锁的第三条，即当资源请求者在请求其他的资源的同时保持对原有资源的占有，当没有完全抢到碗和筷子的时候，两个人（线程）全部释放占有的资源，重新开始争抢资源，这样一个人抢到碗和筷子之后，吃饱再给另一个吃，这样你就成功了拯救了你的两位同事！

Semaphore api：

?

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

acquire

public void acquire()

throws InterruptedException

从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。获取一个许可（如果提供了一个）并立即返回，将可用的许可数减 1。

如果没有可用的许可，则在发生以下两种情况之一前，禁止将当前线程用于线程安排目的并使其处于休眠状态：

某些其他线程调用此信号量的 release() 方法，并且当前线程是下一个要被分配许可的线程；或者

其他某些线程中断当前线程。

如果当前线程：

被此方法将其已中断状态设置为 on ；或者

在等待许可时被中断。

则抛出 InterruptedException，并且清除当前线程的已中断状态。

抛出：

InterruptedException - 如果当前线程被中断

release

public void release()

释放一个许可，将其返回给信号量。释放一个许可，将可用的许可数增加 1。如果任意线程试图获取许可，则选中一个线程并将刚刚释放的许可给予它。然后针对线程安排目的启用（或再启用）该线程。

不要求释放许可的线程必须通过调用 acquire() 来获取许可。通过应用程序中的编程约定来建立信号量的正确用法。

wait()与sleep()的区别：

sleep()方法只让出了CPU，而并不会释放同步资源锁！！！

wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线程得到该资源进而运行;

以上这篇java多线程学习之死锁的模拟和避免(实例讲解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持服务器之家。

本文链接：https://my.lmcjl.com/post/14627.html

展开阅读全文

相关文章

4 评论

留下您的评论.