黑马程序员技术交流社区

标题: 多线程锁的问题 [打印本页]
作者: 乔青山    时间: 2014-3-2 10:05
标题: 多线程锁的问题
本帖最后由 乔青山 于 2014-3-2 14:48 编辑

class Ticket implements Runnable

{
            private int tick = 100;
            Object obj = new Object();
            boolean flag = true;

            public void run(){
                        if(flag){
                                    while(true){
                                                synchronized(obj){            //obj锁
                                                            show();
                                                }
                                    }
                        }else{
                                    while(true)
                                                show();
                        }
            }

            public synchronized void show(){    //this锁
                        synchronized(obj){                       //obj锁
                                    if(tick>0){
                                                try{
                                                            Thread.sleep(10);
                                                }catch(Exception e){
                        
                                            }
                                            System.out.println(Thread.currentThread().getName()+"code.........:"+tick--);
                                    }
                        }
            }
}

class DeadLockDemo
{
            public static void main(String[] args){
                        Ticket t = new Ticket();
               
                        Thread t1 = new Thread(t);        
                        Thread t2 = new Thread(t);        
                        t1.start();
                        try{Thread.sleep(10);}catch(Exception e){}
                        t.flag = false;                                
                        t2.start();
            }
}

我想问一下，什么情况下是this锁，函数上的锁就一定是this锁是么？代码块的锁呢？
另外上面的程序会出现死锁，为什么？t1和t2都在调用show()，那t1执行show的时候t2应该执行不了啊，锁应该锁上了啊，怎么会出现死锁呢？
本人菜鸟，线程同步这个地方学的很吃力，锁有点完全不理解了，希望讲解的能详细一点
作者: 李白衣    时间: 2014-3-2 12:11
本帖最后由 李白衣 于 2014-3-2 12:12 编辑

线程0在flag为true时进入循环，获得锁的过程就是：obj-->this-->obj，obj和obj是同一个锁，所以线程0想要执行下去，就要先获得obj锁，然后获得this锁。
线程1在flag为false的时候进入循环，获得锁的过程是：this-->obj，所以线程1想要执行下去，就要先获得this锁，然后获得obj锁。
这里假设，线程0在获得obj锁后，还没有执行下一句，CPU就切换了，所以线程0拿到了obj的锁。
轮到线程1执行，线程1执行首先就要拿到this锁，this没有被锁定，所以可以继续执行，然后在线程1执行下一句的时候，需要拿到obj的锁，但是obj已经被线程0锁定，无法继续执行下去了。
CPU只有切换到线程0，让线程0来继续执行，但是此时线程0执行下一句就要用到this锁，this锁被线程1锁定了。线程0也无法执行了，这样就成了死锁。更详细的解释：
//代码一
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都被阻塞，程序死锁。

PS：如果在同步代码快里面又写一个同步代码快，很容易变成死锁。
函数上的就是this锁，代码里面this锁就是你new的ticket对象。
作者: 陪你等日出    时间: 2014-3-2 13:10
同步函数的锁是this锁，函数上的锁不一定是this锁，静态同步函数的锁是类的字节码.class，再说程序为什么会出现死锁：
  1. class Ticket implements Runnable

  3. {
  4.         private int tick = 10000;
  5.         Object obj = new Object();
  6.         boolean flag = true;

  8.         public void run(){
  9.                 if(flag){
  10.                         while(true){
  11.                                 //现在0线程要获取obj锁
  12.                                 synchronized(obj){//obj锁  
  13.                                         //现在拥有obj锁的0线程要运行同步方法show()，需要获取this锁
  14.                                         show();
  15.                                         //运行完同步代码后释放锁
  16.                                 }
  17.                         }
  18.                 }else{
  19.                         //现在flag==false，然后1线程开启，执行下面代码，
  20.                         while(true){
  21.                                 //1线程获取了this锁，现在需要获取obj锁  
  22.                                 show();
  23.                                 // 这时0线程拥有obj锁想要获取this锁，1线程拥有了this锁想获取obj锁，两线程都不释放锁，死锁产生
  24.                         }
  25.                 }
  26.         }

  28.         public synchronized void show(){//this锁
  29.                 synchronized(obj){//obj锁
  30.                         if(tick>0){
  31.                                         try{
  32.                                                 Thread.sleep(1);
  33.                                         }catch(Exception e){

  35.                                 }
  36.                                 System.out.println(Thread.currentThread().getName()+"code.........:"+tick--);
  37.                         }
  38.                 }
  39.         }
  40. }

  42. class DeadLockDemo
  43. {
  44.         public static void main(String[] args){
  45.                 Ticket t = new Ticket();

  47.                 Thread t1 = new Thread(t);        
  48.                 Thread t2 = new Thread(t);        
  49.                 t1.start();
  50.                 try{Thread.sleep(10);}catch(Exception e){}
  51.                 t.flag = false;
  52.                 //现在0线程正在执行，刚刚获取到obj锁，正要执行show()方法，需要获取this锁
  53.                 t2.start();
  54.                 //但是1线程执行到else里的show()方法，已经获取了this锁，并且继续向下执行要获取同步代码块中的obj锁
  55.                 //而0线程占有者obj锁需要获取this锁，两线程都不释放各自占有的锁，死锁产生
  56.         }
  57. }
复制代码
作者: 乔青山    时间: 2014-3-2 14:48
李白衣 发表于 2014-3-2 12:11
线程0在flag为true时进入循环，获得锁的过程就是：obj-->this-->obj，obj和obj是同一个锁，所以线程0想要执 ...

谢谢谢谢，已经明白了，太感谢了
作者: 乔青山    时间: 2014-3-2 14:50
陪你等日出 发表于 2014-3-2 13:10
同步函数的锁是this锁，函数上的锁不一定是this锁，静态同步函数的锁是类的字节码.class，再说程序为什么会 ...

静态同步函数的锁是类的字节码，类名.class，非静态函数的锁就是this了 是么？
嗯嗯，死锁的过程明白了，太感谢了。



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