java检查死锁代码 Java中死锁

谁帮我用java编写一个解除操作系统死锁的例子哈

public class DeadLockDemo implements Runnable {

创新互联公司-专业网站定制、快速模板网站建设、高性价比比如网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式比如网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖比如地区。费用合理售后完善，十年实体公司更值得信赖。

DeadLockDemo grabIt; //定义一个本类的对象

public static void main(String[] args) {

DeadLockDemo d1 = new DeadLockDemo(); //实例化1

DeadLockDemo d2 = new DeadLockDemo(); //实例化2

Thread t1 = new Thread(d1); //创建线程t1

Thread t2 = new Thread(d2); //创建线程t2

/**

* grabIt看做类的成员，看成属性或者其他变量的就可以了

* 下面是个交替赋值过程，相当实例d1的成员变量grabIt获得d2引用

* d2类似

*/

d1.grabIt = d2;

d2.grabIt = d1;

/**

* 启动线程t1和t2，调用run方法

*/

t1.start();

t2.start();

//打印输出字符串

System.out.println("已启动死锁");

//下面这句打印main线程在run

// System.out.println(Thread.currentThread().getName() + " is running");

//代码死锁与join语句无关

try {

/**

* t1.join()的作用是把t1对应的线程合并到调用t1.join;语句的线程中。

* 在这个例子中相当与把join到main线程中去

* t2.join()类似

* 作用就是t1和t2线程不执行完，那么main线程中的代码就必须一直等待。

*/

t1.join();

t2.join();

}

catch (InterruptedException e) {

System.out.println("发生错误");

}

/**

* 如果没有join语句，那么代码执行到exit这一步。因为没有join语句main线程就不会等待t1和t2

* 也就是不会造成死锁。

* 在代码中有了join语句，执行到t1.join语句后就会停留，等待t1线程执行完，main线程才会继续接着走下去

* 也就是说有了join语句，下面的语句不会执行到，代码无法正常退出

*/

System.exit(0);

}

/**

* 同步方法使用的锁旗标为this对象，则run方法和syncIt方法使用的是相同的锁棋标。

*/

public synchronized void run() {

try {

/**

* 线程睡觉5 00毫秒

* t1线程进入后然后就睡觉,释放cpu给t2线程，t2到这里也睡觉

* t1先睡醒后接着走，由于run和syncIt使用的是同一个各自对象this的锁棋标

*

*/

Thread.sleep(500);

// System.out.println(Thread.currentThread().getName() + " is running");

}

/*在本例中，我们可以看到一个简单的程序，它按两个不同的时间间隔（ 500毫秒）在屏幕上显示当前时间。这是通过创建两个新线程来完成的，包括 main() 共三个线程。但是，因为有时要作为线程运行的类可能已经是某个类层次的一部分，所以就不能再按这种机制创建线程。虽然在同一个类中可以实现任意数量的接口，但 Java 编程语言只允许一个类有一个父类。同时，某些程序员避免从 Thread 类导出，因为它强加了类层次。对于这种情况，就要 runnable 接口。*/

catch (InterruptedException e) {

System.out.println("发生错误");

}

/**

* 在这里如果是t1线程访问到这里，则相当于调用d2.syncit()方法，类似可推t2线程

* 代码在这里产生死锁，因为t1线程走到这里，需要d2对象的锁棋标，而t2线程走到这里又需要d1的锁棋标

* 因为t1和t2线程使用的是不同对象，所以他们可以先后进入run方法，不需要先进入的线程执行完。

*/

grabIt.syncIt();

}

public synchronized void syncIt() {

try {

//代码根本执行不到这里

//如上

//如果去掉t2线程，那么单独一个t1线程是可以走到这里的，因为t1线程调用的是d2对象的syncIt方法，不需要d1对象的锁旗标

Thread.sleep(500);

//打印

// System.out.println(Thread.currentThread().getName() + " is running");

System.out.println("同步");

}

catch (InterruptedException e) {

System.out.println("发生错误");

}

//打印

System.out.println("在synchIt()方法中");

}

}

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执行cmd命令时出现死锁

line = bufferedReader.readLine();//死锁位置

会等待，所以会。

用另一个线程读、主线程检测是否命令终止了。

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检查死锁代码 Java中死锁
地址分享：http://6mz.cn/article/dodisgd.html