方法锁、对象锁、类锁

java synchronized同步方法调用另一个同步方法，锁机制问题

public synchronized void methodA(int a, int b);

public synchronized void methodB(int a）{
methodA(a, 0);
}

要明白两个问题，1.锁的对象是谁，2.谁持有了锁。
假设方法A和B是在同一个类Test中的两个方法。

Test t=new Test();
t.methodB();

这个时候，methodB方法被调用时，因为加了synchronized ，需要先获得一个锁，这个锁的对象应该是t，也就是当前的这个Test类的实例，而获得锁的东西是线程，也就是说当前线程拿到了t的锁（而不是你说的B方法获得锁），这个时候B方法内调用methodA，因为A也加了synchronized，也需要获得一个锁，因为A和B都是Test类中的方法，所以当前线程要获得的锁的对象也是t。由于当前线程在执行B方法时已经持有了t对象的锁，因此这时候调用methodA是没有任何影响的，相当于方法A上没有加synchronized。

另一种情况：假设现在有两个Test类
Test t1=new Test();
Test t2=new Test();
t1.methodB();//此时当前线程持有了t1对象的锁
t2.methodB();//此时当前线程也持有了t2对象的锁
当前线程持有了两把锁，锁的对象分别是两个不同的Test类的实例t1和t2，互相没有影响。

再一种情况：假设在多线程环境下，两个线程都可以访问Test t=new Test();
此时假设thread1里调用t.methodB();同时thread2里调用t.methodB()

这时假设thread1先抢到t对象的锁,那么thread2需要等待thread1释放t对象的锁才可以执行B方法。
结果像这样：
thread1获得t的锁--thread1执行methodB--thread1执行methodA--释放t的锁---thread2获得t的锁--thread2执行methodB--thread2执行methodA--释放t的锁。

synchronized还有很多种使用方法，但只有明白是 那条线程获得哪个对象的锁，就很容易明白了。

加在非static方法上的synchronized方法是和synchronized（this）块等价的，均为对象锁，即对this加锁。
获得当前对象锁的线程，可以继续获得当前对象锁，JVM负责跟踪对象被加锁的次数。线程运行B方法，此时如果this锁可以用，线程获得该锁，线程给对象加锁，计数器变成1，然后B方法调用A方法，由于是对同一个对象同一个线程，线程可以继续获得锁，计数器变为2，表示this被加锁2次。A方法完毕后，线程释放锁，计数器变为1，此时对象锁对其他线程依然是不可获得的。B方法完毕后，线程继续释放锁，此时计数器变为0，表示锁被完全释放，其他线程可以获得对象锁。

对象锁(方法锁)，是针对一个对象的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，所有它只会锁住当前的对象，一般一个对象锁是对一个非静态成员变量进行synchronized修饰，或者对一个非静态成员方法进行synchronized进行修饰，对于对象锁，不同对象访问同一个被synchronized修饰的方法的时候不会阻塞

类锁是锁住整个类，当有多个线程来声明这个类的对象时候将会被阻塞，直到拥有这个类锁的对象呗销毁或者主动释放了类锁，这个时候在被阻塞的线程被挑选出一个占有该类锁，声明该类的对象。其他线程继续被阻塞住。

无论是类锁还是对象锁，父类和子类之间是否阻塞没有直接关系。当对一个父类加了类锁，子类是不会受到影响的，相反也是如此。因为synchronized关键字并不是方法签名的一部分，它是对方法进行修饰的。当子类覆写父类中的同步方法或是接口中声明的同步方法的时候，synchronized修饰符是不会被自动继承的，所以相应的阻塞问题不会出现。

注意：这里的阻塞问题是指的按照正常情况下应该阻塞，而因为synchronized是父类与子类之间不可传递导致不会阻塞。那正常情况下阻塞是什么那，下面会详细介绍。但是，当一个子类没有覆盖父类的方法的时候，这时候通过子类访问方法则会产生阻塞。

插入一句：构造方法不可能是真正同步的（尽管可以在构造方法中使用同步块）。下面截图给出了如何声明一个对象锁和如何声明一个类锁：

1 void myMethod(){
 2     synchronized(this){
 3         //code
 4     }
 5 }
 6 
 7 /*is equvilant to*/
 8 void synchronized myMethod(){
 9     //code
10 }

当同一个对象在线程1中访问一个方法，在线程2中再去访问另外一个加锁方法，则同样也会被阻塞.

对于类锁，则会把整个类锁住，也就说只能有一个对象拥有当前类的锁。当一个对象拥有了类锁之后，另外一个对象还想竞争锁的话则会被阻塞。两个对象A，B，如果A正在访问一个被类锁修饰的方法function，那么B则不能访问。因为类锁只能在同一时刻被一个对象拥有。相对于对象锁，则是不同。还是A，B两个对象，如果A正在访问对象锁修饰的function，那么这个时候B也可以同时访问。

对于对象锁，当一个对象拥有锁之后，访问一个加了对象锁的方法，而该方法中又调用了该类中其他加了对象锁的方法，那么这个时候是不会阻塞住的。这是java通过可重入锁机制实现的。可重入锁指的是当一个对象拥有对象锁之后，可以重复获取该锁。因为synchronized块是可重入的，所以当你访问一个对象锁的方法的时候，在该方法中继续访问其他对象锁方法是不会被阻塞的。

首先的明白Java中锁的机制

synchronized 
在修饰代码块的时候需要一个reference对象作为锁的对象. 
在修饰方法的时候默认是当前对象作为锁的对象. 
在修饰类时候默认是当前类的Class对象作为锁的对象.

线程同步的方法：sychronized、lock、reentrantLock分析 
方法锁（synchronized修饰方法时）

---

通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。

synchronized 方法控制对类成员变量的访问： 
每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态，从而有效避免了类成员变量的访问冲突。

　对象锁（synchronized修饰方法或代码块）

　　当一个对象中有synchronized method或synchronized block的时候调用此对象的同步方法或进入其同步区域时，就必须先获得对象锁。如果此对象的对象锁已被其他调用者占用，则需要等待此锁被释放。（方法锁也是对象锁） 　　 　　　

java的所有对象都含有1个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象的锁，当然如果已经有线程获取了这个对象的锁，那么当前线程会等待；synchronized方法正常返回或者抛异常而终止，JVM会自动释放对象锁。这里也体现了用synchronized来加锁的1个好处，方法抛异常的时候，锁仍然可以由JVM来自动释放。　

对象锁的两种形式：

public class Test 
{ 
// 对象锁：形式1(方法锁) 
public synchronized void Method1() 
{ 
System.out.println(“我是对象锁也是方法锁”); 
try 
{ 
Thread.sleep(500); 
} catch (InterruptedException e) 
{ 
e.printStackTrace(); 
}

}

// 对象锁：形式2（代码块形式）
public void Method2()
{
    synchronized (this)
    {
        System.out.println("我是对象锁");
        try
        {
            Thread.sleep(500);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }

}

｝

类锁(synchronized 修饰静态的方法或代码块)

　　由于一个class不论被实例化多少次，其中的静态方法和静态变量在内存中都只有一份。所以，一旦一个静态的方法被申明为synchronized。此类所有的实例化对象在调用此方法，共用同一把锁，我们称之为类锁。 　

对象锁是用来控制实例方法之间的同步，类锁是用来控制静态方法（或静态变量互斥体）之间的同步。　

类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。　 
java类可能会有很多个对象，但是只有1个Class对象，也就是说类的不同实例之间共享该类的Class对象。Class对象其实也仅仅是1个java对象，只不过有点特殊而已。由于每个java对象都有1个互斥锁，而类的静态方法是需要Class对象。所以所谓的类锁，不过是Class对象的锁而已。获取类的Class对象有好几种，最简单的就是［类名.class］的方式。

public class Test 
{ 
　　 // 类锁：形式1 
public static synchronized void Method1() 
{ 
System.out.println(＂我是类锁一号＂); 
try 
{ 
Thread.sleep(500); 
} catch (InterruptedException e) 
{ 
e.printStackTrace(); 
}

}

// 类锁：形式2
public void Method２()
{
    synchronized (Test.class)
    {
        System.out.println(＂我是类锁二号＂);
        try
        {
            Thread.sleep(500);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }

    }

}

｝

*后续 
附上一个讲的挺清晰的关于同步代码块的链接同步代码块