Synchronized方法锁、对象锁、类锁区别

synchronized，这个东西我们一般称之为”同步锁“，他在修饰代码块的时候需要传入一个引用对象作为“锁”的对象。

1. 在修饰方法的时候，默认是当前对象作为锁的对象
2. 在修饰类时，默认是当前类的Class对象作为所的对象
   故存在着方法锁、对象锁、类锁 这样的概念
   那么我们来大致看一下这三种锁

一、方法锁（synchronized修饰方法时）（其实也可以算是对象锁）

通过在方法声明中加入synchronized关键字来声明synchronized方法。
synchronized 方法锁控制对类成员变量的访问：
每个类实例对应一把锁
每个synchronized方法都必须获得调用该方法的类实例的”锁“方能执行，否则所属线程阻塞。

方法一旦执行，就会独占该锁，一直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，从而重新进入可执行状态。

这种机制确保了同一时刻对于每一个类的实例，其所有声明为synchronized的成员函数中之多只有一个处于可执行状态，从而有效避免了类成员变量的访问冲突。

ok,下方介绍一个火车站卖票的例子，一共1000张票，有4个窗口卖票，卖票的方法被我定义为同步的，即每个卖票过程会卖出4张票，卖完之后才允许其他窗口卖票

大家看看代码，体会一下

public class LockTest {
    static int tickets = 1000;

    public synchronized void sellTickets(){
        int i=4;
        while (i>0){
            i--;
            tickets--;
            System.out.println(Thread.currentThread().getName()+":"+tickets);
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockTest.sellTickets();
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockTest.sellTickets();
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockTest.sellTickets();
            }
        });
        Thread thread4 = new Thread(new Runnable() {
            @Override
            public void run() {
                lockTest.sellTickets();
            }
        });
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

运行结果如下：

运行结果多运行几次会发现虽然线程的先后顺序会变化，但是每一个线程必定先卖出4张票之后才会去接着卖剩余的票。

下边我们来看下对象锁，其实方法锁 这个就属于对象锁

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

当一个对象中有synchronized method 或synchronized block 的时候，调用此对象的同步方法或进入其同步区域时，就必须先获得对象锁。

如果此对象的对象锁已被其他调用者占用，则需要等待此锁被释放。（方法锁也是对象锁）

java的所有对象都含有一个互斥锁，这个锁由jvm自动获取和释放。

线程进入synchronized 方法的时候获取该对象的锁，当然如果已经有线程获取了这个对象的锁，那么当前线程会等待；

synchronized方法正常返回或者抛异常而终止，jvm会自动释放对象锁。这里也体现了用synchronized来加锁的一个好处，即 ：

方法抛异常的时候，锁仍然可以由jvm来自动释放
对象锁的两种方式

1、方法锁，上面已提及。

2、代码块形式

public void sellTickets(){
        int i=4;
        synchronized(this) {
            while (i > 0) {
                i--;
                tickets--;
                System.out.println(Thread.currentThread().getName() + ":" + tickets);
            }
        }
    }

执行效果一样。

三、类锁（synchronized修饰静态的方法或者代码块）

由于一个class不论被实例化多少次，其中的静态方法和静态变量在内存中都只有一份。所以，一旦一个静态的方法被声明为synchronized。此类所有的实例对象在调用此方法，共用同一把锁，我们称之为类锁。
对象锁是用来控制实例方法之间的同步，而类锁是用来控制静态方法（或者静态变量互斥体）之间的同步的。
类锁只是一个概念上的东西，并不是真实存在的，他只是用来帮助我们理解锁定实例方法和静态方法的区别的。
java类可能会有很多对象，但是只有一个Class(字节码)对象，也就是说类的不同实例之间共享该类的Class对象。Class对象其实也仅仅是1个java对象，只不过有点特殊而已。
由于每个java对象都有1个互斥锁，而类的静态方法是需要Class对象。所以所谓的类锁，只不过是Class对象的锁而已。
获取类的Class对象的方法有好几种，最简单的是[类名.class]的方式。(百度：获取字节码的三种方式)

来看下类锁的两种方式
方式1：

public void sellTickets(){
        int i=4;
        synchronized(LockTest.class) {
            while (i > 0) {
                i--;
                tickets--;
                System.out.println(Thread.currentThread().getName() + ":" + tickets);
            }
        }
    }

方式2：

public static synchronized void sellTickets(){
        int i=4;
        while (i > 0) {
            i--;
            tickets--;
            System.out.println(Thread.currentThread().getName() + ":" + tickets);
        }
    }