死锁的java代码 java死锁的简单例子

java 死锁

死锁

公司主营业务：成都网站建设、网站设计、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。创新互联公司是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。创新互联公司推出临泽免费做网站回馈大家。

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

导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。“synchronized”关键词的作用是，确保在某个时刻只有一个线程被允许执行特定的代码块，因此，被允许执行的线程首先必须拥有对变量或对象的排他性的访问权。当线程访问对象时，线程会给对象加锁，而这个锁导致其它也想访问同一对象的线程被阻塞，直至第一个线程释放它加在对象上的锁。

由于这个原因，在使用“synchronized”关键词时，很容易出现两个线程互相等待对方做出某个动作的情形。代码一是一个导致死锁的简单例子。

//代码一

class Deadlocker {

int field_1;

private Object lock_1 = new int[1];

int field_2;

private Object lock_2 = new int[1];

public void method1(int value) {

“synchronized” (lock_1) {

“synchronized” (lock_2) {

field_1 = 0; field_2 = 0;

}

}

}

public void method2(int value) {

“synchronized” (lock_2) {

“synchronized” (lock_1) {

field_1 = 0; field_2 = 0;

}

}

}

}

参考代码一，考虑下面的过程：

◆ 一个线程（ThreadA）调用method1()。

◆ ThreadA在lock_1上同步，但允许被抢先执行。

◆ 另一个线程（ThreadB）开始执行。

◆ ThreadB调用method2()。

◆ ThreadB获得lock_2，继续执行，企图获得lock_1。但ThreadB不能获得lock_1，因为ThreadA占有lock_1。

◆ 现在，ThreadB阻塞，因为它在等待ThreadA释放lock_1。

◆ 现在轮到ThreadA继续执行。ThreadA试图获得lock_2，但不能成功，因为lock_2已经被ThreadB占有了。

◆ ThreadA和ThreadB都被阻塞，程序死锁。

当然，大多数的死锁不会这么显而易见，需要仔细分析代码才能看出，对于规模较大的多线程程序来说尤其如此。好的线程分析工具，例如JProbe Threadalyzer能够分析死锁并指出产生问题的代码位置。

隐性死锁

隐性死锁由于不规范的编程方式引起，但不一定每次测试运行时都会出现程序死锁的情形。由于这个原因，一些隐性死锁可能要到应用正式发布之后才会被发现，因此它的危害性比普通死锁更大。下面介绍两种导致隐性死锁的情况：加锁次序和占有并等待。

加锁次序

当多个并发的线程分别试图同时占有两个锁时，会出现加锁次序冲突的情形。如果一个线程占有了另一个线程必需的锁，就有可能出现死锁。考虑下面的情形，ThreadA和ThreadB两个线程分别需要同时拥有lock_1、lock_2两个锁，加锁过程可能如下：

◆ ThreadA获得lock_1；

◆ ThreadA被抢占，VM调度程序转到ThreadB；

◆ ThreadB获得lock_2；

◆ ThreadB被抢占，VM调度程序转到ThreadA；

◆ ThreadA试图获得lock_2，但lock_2被ThreadB占有，所以ThreadA阻塞；

◆ 调度程序转到ThreadB；

◆ ThreadB试图获得lock_1，但lock_1被ThreadA占有，所以ThreadB阻塞；

◆ ThreadA和ThreadB死锁。

必须指出的是，在代码丝毫不做变动的情况下，有些时候上述死锁过程不会出现，VM调度程序可能让其中一个线程同时获得lock_1和lock_2两个锁，即线程获取两个锁的过程没有被中断。在这种情形下，常规的死锁检测很难确定错误所在。

占有并等待

如果一个线程获得了一个锁之后还要等待来自另一个线程的通知，可能出现另一种隐性死锁，考虑代码二。

//代码二

public class queue {

static java.lang.Object queueLock_;

Producer producer_;

Consumer consumer_;

public class Producer {

void produce() {

while (!done) {

“synchronized” (queueLock_) {

produceItemAndAddItToQueue();

“synchronized” (consumer_) {

consumer_.notify();

}

}

}

}

public class Consumer {

consume() {

while (!done) {

“synchronized” (queueLock_) {

“synchronized” (consumer_) {

consumer_.wait();

}

removeItemFromQueueAndProcessIt();

}

}

}

}

}

}

在代码二中，Producer向队列加入一项新的内容后通知Consumer，以便它处理新的内容。问题在于，Consumer可能保持加在队列上的锁，阻止Producer访问队列，甚至在Consumer等待Producer的通知时也会继续保持锁。这样，由于Producer不能向队列添加新的内容，而Consumer却在等待Producer加入新内容的通知，结果就导致了死锁。

在等待时占有的锁是一种隐性的死锁，这是因为事情可能按照比较理想的情况发展—Producer线程不需要被Consumer占据的锁。尽管如此，除非有绝对可靠的理由肯定Producer线程永远不需要该锁，否则这种编程方式仍是不安全的。有时“占有并等待”还可能引发一连串的线程等待，例如，线程A占有线程B需要的锁并等待，而线程B又占有线程C需要的锁并等待等。

要改正代码二的错误，只需修改Consumer类，把wait()移出“synchronized”()即可。

java产生死锁原因，代码如下。

你这个不是死锁，就是flag的判断有问题，每个线程都是自己把自己锁住了，当flag为true时，看以下两段代码：

public synchronized void set(String name) {

if (flag)

try {

wait();

public synchronized void out() {

if (flag)

try {

wait();

两个线程都在wait，当然卡住不动了。

看你的代码，把set那段改成这样应该就好了：

public synchronized void set(String name) {

if (!flag)

try {

wait();

java线程同步，死锁题目求代码

可以建一个类作为锁   然后两个线程

......

synchronized (seed) {

......

seed.notifyAll();

try {

seed.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

以下仅供参考

package com.kidd.test.zhidao;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Random;

/**

* Hello world!

*

*/

public class Main {

public static void main(String[] args) {

ListInteger pais = new ArrayList();

ListInteger list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);

pais.addAll(list);

pais.addAll(list);

Seed seed = new Seed();

Person person1 = new Person(0, "玩家A", seed);

Person person2 = new Person(1, "玩家B", seed);

fapai(pais, person1, person2);

Thread thread1 = new Thread(person1);

Thread thread2 = new Thread(person2);

thread1.start();

thread2.start();

}

private static void fapai(ListInteger pais, Person person1, Person person2) {

int i = 1;

int index;

Random random = new Random();

while (pais.size()  0) {

switch (i) {

case 1: {

index = pais.remove(random.nextInt(pais.size()));

person1.addPai(index);

i++;

break;

}

case 2: {

index = pais.remove(random.nextInt(pais.size()));

person2.addPai(index);

i = 1;

break;

}

}

}

Arrays.sort(person1.getPais());

Arrays.sort(person2.getPais());

System.out.println("牌发完了.");

System.out.println(person1.getName() + ":我的牌组是" + Arrays.toString(person1.getPais()));

System.out.println(person2.getName() + ":我的牌组是" + Arrays.toString(person1.getPais()));

}

}

class Person implements Runnable {

private int index;

private int n;

private int[] pais = new int[13];

private String name;

private Seed seed;

public Person(int index, String name, Seed seed) {

this.index = index;

this.name = name;

this.seed = seed;

}

public Seed getSeed() {

return seed;

}

public String getName() {

return name;

}

public int[] getPais() {

return pais;

}

public void setPais(int[] pais) {

this.pais = pais;

}

public int getN() {

return n;

}

public int addPai(int i) {

pais[n] = i;

n++;

return n;

}

@Override

public void run() {

synchronized (seed) {

while (!seed.isEnd()  n != 0) {

/**

 * 判断是否轮到该玩家出牌,否则唤醒其他线程并且该线程睡眠.

 */

while (seed.getIndex() != this.index) {

seed.notifyAll();

try {

seed.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

/**

 * 线程唤醒后,检查中断标记

 */

if (seed.isEnd()) {

break;

}

/**

 * 判断出牌是否成功,成功就轮到下一个玩家.否则重置牌,并轮到下一个玩家.

 */

if (chupai()) {

seed.nextIndex();

} else {

seed.nextIndex();

seed.setPai(0);

}

}

/**

 * 设置线程退出的标记

 */

seed.setEnd(true);

if (n == 0) {

System.out.println(name + ":牌出完了,我赢了.");

} else {

System.out.println(name + ":我输了.还剩" + n + "张牌.牌组是:" + Arrays.toString(pais));

}

/**

 * 退出前把其他线程唤醒.

 */

seed.notifyAll();

}

}

private boolean chupai() {

int a;

for (int i = 0, k = pais.length; i  k; i++) {

a = pais[i];

if (a != 0  a  seed.getPai()) {

System.out.println(name + ":大你。我出" + pais[i]);

seed.setPai(a);

pais[i] = 0;

n--;

return true;

}

}

System.out.println(name + "不出牌：(无牌可出).");

return false;

}

}

class Seed {

private boolean end;

private int pai;

private int index;

public boolean isEnd() {

return end;

}

public int getPai() {

return pai;

}

public void setPai(int pai) {

this.pai = pai;

}

public int getIndex() {

return index;

}

public void nextIndex() {

this.index++;

if (this.index == 2) {

this.index = 0;

}

}

public void setEnd(boolean end) {

this.end = end;

}

}