上一节讲到Synchronized关键字，synchronized上锁的区域：对象锁=方法锁/类锁

本节补充介绍一下synchronized锁重入：

关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时，是可以再次得到该对象锁的。这也证明在一个synchronized方法/块内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。

(写在例子前面一个维基百科关于可重入的概念)若一个程序或子程序可以“在任意时刻被中断然后操作系统调度执行另外一段代码，这段代码又调用了该子程序不会出错”，则称其为可重入(reentrant或re-entrant)的。即当该子程序正在运行时，执行线程可以再次进入并执行它，仍然获得符合设计时预期的结果。与多线程并发执行的线程安全不同，可重入强调对单个线程执行时重新进入同一个子程序仍然是安全的。通俗来说：当线程请求一个由其它线程持有的对象锁时，该线程会阻塞，而当线程请求由自己持有的对象锁时，如果该锁是重入锁，请求就会成功，否则阻塞。

public classService {synchronized public voidservice1(){

System.out.println("service1");

service2();

}synchronized public voidservice2(){

System.out.println("service2");

service3();

}synchronized public voidservice3(){

System.out.println("service3");

}

}public class MyThread extendsThread {

@Overridepublic voidrun(){

Service service= newService();

service.service1();

}

}public classRun {public static voidmain(String[] args) {

MyThread t= newMyThread();

t.start();

}

}

可重入锁的概念是自己可以再次获得自己的内部锁，比如有一个线程获得了某个对象的锁，此时这个对象的锁还没有释放，当他再次想要获得这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。

此时就会出现问题：对象的锁和类锁？区别是什么

1. 类锁：在代码中的方法上加了static和synchronized的锁，或者synchronized(xxx.class)的代码段；

2.对象锁：在代码中的方法上加了synchronized的锁，或者synchronized(this)的代码段；

对象锁也叫方法锁，是针对一个对象实例的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，所有它只会锁住当前的对象，而并不会对其他对象实例的锁产生任何影响，不同对象访问同一个被synchronized修饰的方法的时候不会阻塞。

类锁是锁住整个类，当有多个线程来声明这个类的对象时候将会被阻塞，直到拥有这个类锁的对象被销毁或者主动释放了类锁，这个时候在被阻塞的线程被挑选出一个占有该类锁，声明该类的对象。其他线程继续被阻塞住，即一句话：不管多少个对象,多少个对象,共用一把锁,且只有一把,不管怎么调用,都会同步

这里介绍一下可重入锁与不可重入锁，首先列举一个不可重入锁的例子：

public classLock {private boolean isLocked = false;public synchronized void lock() throwsInterruptedException {while(isLocked) {

System.out.println("isLocked...");

wait();

}

isLocked= true;

System.out.println("Locked! ... ");

}public synchronized voidunlock() {

isLocked= false;

System.out.println("notify() !");

notify();

}

}public classCount {

Lock lock= newLock();public void print() throwsInterruptedException {

lock.lock();

doAdd();

lock.unlock();

}public void doAdd() throwsInterruptedException {

lock.lock();//do something

System.out.println("i'm doing something...");

lock.unlock();

}public static void main(String[] args) throwsInterruptedException {

Count c= newCount();

c.print();

}

}

运行结果为：

Locked!...

isLocked...

当调用print()方法时，获得了锁，这时就无法再调用doAdd()方法，这时必须先释放锁才能调用，所以称这种锁为不可重入锁，也叫自旋锁。

同一个类的多个方法被synchronized修饰，他们是同一把锁吗(针对上文代码中的service1 service2 service3之间的调用)

synchronized是Java中的关键字，是一种同步锁。修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；修饰方法时锁定的是调用该方法的对象，即如果一个对象中有两个方法同时被synchronized，则同一个对象，调用这两个方法时，只能同时执行一个。但它并不能使调用该方法的多个对象在执行顺序上互斥。

如以下代码，只能同时执行set方法或out方法：

classResoure{privateString name;private int count = 1;//生产者调用

public synchronized voidset(String name){this.name = name+count;//编号自增

count++;//打印生产了哪个产品

System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);

}//消费者调用

public synchronized voidout(){

System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name);

}

}

再来一个可重入代码的对比：

public class Xttblog extendsSuperXttblog {public static voidmain(String[] args) {

Xttblog child= newXttblog();

child.doSomething();

}public synchronized voiddoSomething() {

System.out.println("child.doSomething()" +Thread.currentThread().getName());

doAnotherThing();//调用自己类中其他的synchronized方法

}private synchronized voiddoAnotherThing() {super.doSomething(); //调用父类的synchronized方法

System.out.println("child.doAnotherThing()" +Thread.currentThread().getName());

}

}classSuperXttblog {public synchronized voiddoSomething() {

System.out.println("father.doSomething()" +Thread.currentThread().getName());

}

}

输出结果为：

child.doSomething()Thread-5492father.doSomething()Thread-5492child.doAnotherThing()Thread-5492

现在可以验证出 synchronized 是可重入锁了吧！因为这些方法输出了相同的线程名称，表明即使递归使用synchronized也没有发生死锁，证明其是可重入的。

还看不懂？那我就再解释下！

这里的对象锁只有一个，就是 child 对象的锁，当执行 child.doSomething 时，该线程获得 child 对象的锁，在 doSomething 方法内执行 doAnotherThing 时再次请求child对象的锁，因为synchronized 是重入锁，所以可以得到该锁，继续在 doAnotherThing 里执行父类的 doSomething 方法时第三次请求 child 对象的锁，同样可得到。如果不是重入锁的话，那这后面这两次请求锁将会被一直阻塞，从而导致死锁。

所以在 java 内部，同一线程在调用自己类中其他 synchronized 方法/块或调用父类的 synchronized 方法/块都不会阻碍该线程的执行。就是说同一线程对同一个对象锁是可重入的，而且同一个线程可以获取同一把锁多次，也就是可以多次重入。因为java线程是基于“每线程(per-thread)”，而不是基于“每调用(per-invocation)”的(java中线程获得对象锁的操作是以线程为粒度的，per-invocation 互斥体获得对象锁的操作是以每调用作为粒度的)。

直接看结论：

从互斥锁的设计上来说，当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁，请求将会成功，在java中synchronized是基于原子性的内部锁机制，是可重入的，因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，也就是说一个线程得到一个对象锁后再次请求该对象锁，是允许的，这就是synchronized的可重入性。

可重入锁的实现原理？

看到这里，你终于明白了 synchronized 是一个可重入锁。但是面试官要再问你，可重入锁的原理是什么？

对不起，你又卡壳了。

可重入锁的原理。具体我们后面再写 ReentrantLock 的时候来验证或看它源码。

重入锁实现可重入性原理或机制是：每一个锁关联一个线程持有者和计数器，当计数器为 0 时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；当某一线程请求成功后，JVM会记下锁的持有线程，并且将计数器置为 1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为 0，则释放该锁。