java中锁对象本身是可以修改的

public class Apple {

    private int color;

    public Apple(int color)
    {
        this.color = color;
    }

    public int getColor() {
        return color;
    }

    //终止于这步
    public synchroized void  setColor(int color) {
        this.color = color;
    }

}

 

public class TestDeadLock implements Runnable{

     int flag = 1;
     static Apple o1 = (Apple) new Apple(3);  //资源1，也称为锁
     static Apple o2 = (Apple) new Apple(3);  //资源2，也称为锁

 public static void main(String[] args) {
      TestDeadLock td1 = new TestDeadLock();
      TestDeadLock td2 = new TestDeadLock();
      td1.flag = 1;
      td2.flag = 0;
      Thread t1 = new Thread(td1);
      Thread t2 = new Thread(td2);
      t1.start();
      t2.start();
 }


 public void run() {
      if(flag == 1){
           synchronized(o1)  //判断括号内对象是否在其他线程中锁定
           {
                try {
                      Thread.sleep(1000);
                } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                }
                o2.setColor(8);  //发生死锁
                System.out.println("2:" + o2.getColor());
           }
      }

     if(flag == 0){
           synchronized(o2){
                System.out.println("1:" + o2.getColor());

                synchronized(o1){
                      System.out.println("t2 succeed");
                }
           }
      }
 }

}

 

当 Apple 类中setColor（）方法前没有synchronized，则输出如下：

1:3
2:8
t2 succeed
当该方法前有synchronized，则构成了死锁。

由此可见：

（1）锁对象本身是可以修改的。

（2）当给一个方法前加上synchronized，则相当于synchronized（该方法所属的对象）。

（3）synchronized（锁）该语句会判断这个锁是否在某处已用，如果用，那么就阻塞当前线程。