黑马程序员技术交流社区

标题: 关于多线程死锁的问题 [打印本页]
作者: 周亮    时间: 2012-12-22 22:41
标题: 关于多线程死锁的问题
今日看老毕视频讲多线程的时候提到了这么一个问题，就是关于同步的，同步有两种表现形式，1同步代码块。2同步函数。
说道同步函数就想到这么个问题，同步函数的死锁是什么呢？怎么用代码来验证呢？
作者: 郭俊    时间: 2012-12-22 23:42
  死锁就是共享资源被占用，线程会一直等待，或者是两个线程相互想使用对方的资源，在没有得到对方资源情况下，又不释放自己的资源，这时两个线程都不往下走，也会造成死锁。
  1. public class Test {
  2.         public static void main(String[] args) {
  3.                 A a1 = new A();
  4.                 A a2 = new A();
  5.                 Thread t1 = new Thread1(a1, a2);
  6.                 Thread t2 = new Thread1(a2, a1);
  7.                 t1.start();
  8.                 t2.start();
  9.         }
  10. }
  11. class Thread1 extends Thread {
  12.         private A from;
  13.         private A to;
  14.        
  15.         public Thread1(A from, A to) {
  16.                 this.from = from;
  17.                 this.to = to;
  18.         }
  19.         public void run() {
  20.                 from.fun1(to);
  21.         }
  22. }
  23. class A {
  24.         public synchronized void fun1(A a) {
  25.                 System.out.println(Thread.currentThread().getName() + ": fun1()...");
  26.                 try {
  27.                         Thread.sleep(1000);
  28.                 } catch(InterruptedException e) {}
  29.         a.fun2();
  30.         }
  31.         public synchronized void fun2() {}
  32. }
复制代码
作者: 罗海清    时间: 2012-12-23 10:56
1、死锁和所有进程都在等待而不能执行是两回事
2、死锁是，你等我释放资源，我也在等你释放资源，这就是死锁
3、所有进程都在等待不是死锁，你可以认为的调用所有进程的wait()方法，可以使他们都在等待，而都不执行。
4、代码实现我的水平，还写不出来
作者: ︶ㄣ布丁    时间: 2012-12-23 12:02
死锁分析：
        现在有两个线程，都能读写相同的共享数据。这样就带来了新的麻烦：由于数据共享会带来同步问题，进而会导致死锁的产生。
        众所周知，多线程带来的好处是显而易见的，特别是性能的改善；但这个是以牺牲可靠性为代价的，主要是因为多线程共享数据有可能会产生线程死锁。举个简单的例子：第一个线程等待第二个线程释放资源，而同时第二个线程又在等待第 一个线程释放资源。双方互不相让，死锁发生，程序不能正常运行。人的现实生活又何尝不是这样，很多时候都出现对峙的状态。要是每个人都这样想就好了：只要不是涉及原则问题和自己的核心利益，退一步海阔天空。当然了，说起来容易做起来难，这是理想情况，只能往这方面努力了。
        导致死锁的根源在于不适当地运用“synchronized”同步关键词来管理线程对特定对象的访问而引起的。“synchronized”关键词的作用是，确保在某 个时刻只有一个线程被允许执行特定的同步代码块，因此，被允许执行的线程首先必须拥有对该变量或对象的排他性访问权。Java中每个对象都有一把锁与之对应。当线程访问对象时，线程会给对象加锁（监视器），而这 个锁导致其它也想访问同一对象的线程被阻塞，直至第一个线程释放它加在对象上的锁。


作者: 罗利华    时间: 2012-12-29 18:33
死锁的经典案例：
有一群科学家应邀来我家吃饭，但是我只给每个人一根筷子，当他们坐在餐桌上时，
谁也没有动筷子，他们就处于等待状态。只有当某个人给他一根筷子时，他才会执行吃的动作。
作者: 梁俊    时间: 2013-1-2 21:20
死锁实例代码
  1. public class Demo {
  2.         public static void main(String[] args) {
  3.                 Thread t1 = new Thread1();
  4.                 Thread t2 = new Thread2();
  5.                 t1.start();
  6.                 t2.start();
  7. }
  8. class Thread1 extends Thread{
  9.         public void run(){
  10.                 synchronized(Thread1.class){
  11.                         try{
  12.                                 System.out.println("Thread1");
  13.                                 Thread.sleep(100);
  14.                         }catch(InterruptedException e){}
  15.                         synchronized(Thread2.class){
  16.                               
  17.                         }
  18.                 }
  19.         }
  20. }
  21. class Thread2 extends Thread{
  22.         public void run(){
  23.                 synchronized(Thread2.class){
  24.                         try{
  25.                                 System.out.println("Thread2");
  26.                                 Thread.sleep(100);
  27.                         }catch(InterruptedException e){}
  28.                         synchronized(Thread1.class){}
  29.                 }
  30.         }
  31. }
复制代码
作者: 严海荣    时间: 2013-1-2 22:33
简言之 同步中嵌套同步，而且不同锁。




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2