关于synchronized，对象锁的理解

其实对象锁这个对象指的是拥有synchronized修饰的函数，或者是代码块的一个类的实例。 当某个线程访问该类的方法或synchronized修饰的代码快时，就获得该对象的锁，其他线程就无法获得该对象的锁，也就是说这个对象已经被前一个线程所占用，另外的线程无法得到该对象，所以该对象对应的方法也就无法访问，必须等到前一个线程释放对象锁才可能有机会得到对象锁。

代码说明：

public class 对象锁1 {

    public static void main(String[] args) {
        CSD cs = new CSD();
        CSD cs1 = new CSD();
        // 两个对象的线程是同一个
        Thread th1 = new Thread(cs);
        Thread th2 = new Thread(cs);
        th1.start();
        th2.start();
    }
}


class CSD implements Runnable{

    public int  a;

    @Override
    public void run() {
        synchronized (this) { // 该对象锁就为cs
            a++;
            try {
                System.out.println("【当前线程】-----"+Thread.currentThread().getName()+"----a---"+a);
                Thread.sleep(2000);// 休眠2秒
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

输出：

先打印：【当前线程】-----Thread-1----a---1  
隔2秒钟  
再打印：【当前线程】-----Thread-0----a---2  

原因：
因为加了synchronzied，实现了同步，并且该对象锁对应的对象只有一个，那就是cs,所以当第一个线程锁住了cs，而第二个线程里面也是通过cs去访问run（）方法，所以必须等第一个线程执行完对象的方法时才能获得对象锁。因此必须隔2秒钟才能执行当前线程

---

改动代码：

public class 对象锁2 {

    public static void main(String[] args) {
        CSD cs = new CSD();
        CSD cs1 = new CSD();
        // 两个对象的线程是同一个
        Thread th1 = new Thread(cs);
        Thread th2 = new Thread(cs1);
        th1.start();
        th2.start();
    }
}


class CSD implements Runnable{

    public int  a;

    @Override
    public void run() {
        synchronized (this) { // 该对象锁就为cs
            a++;
            try {
                System.out.println("【当前线程】-----"+Thread.currentThread().getName()+"----a---"+a);
                Thread.sleep(2000);// 休眠2秒
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

输出：

先打印：【当前线程】-----Thread-1----a---1  
不隔2秒钟  
再打印：【当前线程】-----Thread-0----a---2  

原因：
因为此时每个线程都是通过不同的对象去访问run()方法，一个为cs,另外一个为cs1,所以有2把对象锁，这2个对象锁毫不干，第一个线程锁住了cs，而第二个线程都是通过 cs1对象去访问的，所以仍然能访问该方法。

1. java中的每个对象都有一个锁，当访问某个对象的 synchronized方法时，表示将该对象上锁，此时其他任何线程都无法在去访问该 syncronized 方法了，直到之前的那个线程执行方法完毕后，其他线程才有可能去访问该 synchronized方法。

2. 如果一个对象有多个 synchronized方法，某一时刻某个线程已经进入到某个synchronzed方法，那么在该方法没有执行完毕前，其他线程无法访问该对象的任何 synchronzied 方法的，但可以访问非 synchronzied方法。

3. 如果 synchronized方法是 static的，那么当线程访问该方法时，它锁的并不是 synchronized方法所在的对象，而是 synchuronized方法所在对象的对应的 Class对象，因为 java中无论一个类有多少个对象，这些对象会对应唯一一个 Class 对象，因此当线程分别访问同一个类的两个对象的 static，synchronized方法时，他们的执行也是按顺序来的，也就是说一个线程先执行，一个线程后执行。

原文链接：
https://jasshine.iteye.com/blog/1617813