synchronized锁重入

关键字synchronized拥有锁重人的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的（必须保证该对象锁，还没有释放）。这也证明在一个synchronized 方法/块的内部调用本类的其他synchronized 方法/块时，是永远可以得到锁的。（获得的锁是同一个对象锁，不可能是其他的）

public class Test170 {
        public static void main(String[] args) {
            Thread t = new Thread(new MyThreadThree());
            t.start();
        }

        synchronized public void show1() {
            System.out.println("show1");
            show2();
        }
        synchronized public void show2() {
            System.out.println("show2");
        }
}
class MyThreadThree implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        Test170 t = new Test170();
        t.show1();

    }

}

两个方法都能执行到。

“可重人锁”的概念是: 自己可以再次获取自己的内部锁。

比如有1条线程获得了某个对象的锁，此时这个对象锁还没释放，当其再次想要获取这个对象的锁的时候还是可以获
取的，如果不可锁重人的话，就会造成死锁。

可重入锁在继承关系下的使用：

父类

public class Test173 {
  synchronized  public void show() {
      for(int i =0;i<200;i++) {
             System.out.println(Thread.currentThread().getName()+"这时父类类的synchronized方法"+i);
        }
   }
}

子类

public class Test174 extends Test173{
        synchronized public void show() {
            for(int i =0;i<100;i++) {
                 System.out.println(Thread.currentThread().getName()+"这时子类类的synchronized方法"+i);
            }
             super.show();//执行父类的方法
        }
}

public class Test175 {
   public static void main(String[] args) {
       Test174 t4 = new Test174();
       MyThreadFive mtf = new MyThreadFive(t4);
       Thread t = new Thread(mtf);
       Thread t1 = new Thread(mtf);
       t.setName("t");
       t1.setName("t1");
       t.start();
       t1.start();
    }
}
class MyThreadFive implements Runnable{
    private Test174 t;
    public MyThreadFive(Test174 t) {
        super();
        this.t = t;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        t.show();
    }
}

上述代码执行过程：两个线程持有同一个对象，拥有同一个对象锁，另外方法中采用了synchronized 关键字修饰，当一个线程拿到对象锁之后，先执行子类的任务，然后执行父类的，整个过程都是同步的。