静态方法加锁，和非静态方法加锁区别

面试的时候说道了单例，又扯到了加锁等。后来面试官问了问静态方法加锁和非静态方法加锁的区别。结果尴尬了，还是自己没有太动脑筋，其实挺容易能够想到的。

---

static方法调用方式是通过class.fun，而非static方法调用是先new出这个对象，再调用。

static synchronized是类锁，synchronized是对象锁。

• 对象锁（又称实例锁，synchronized）：该锁针对的是该实例对象（当前对象）。
  synchronized是对类的当前实例（当前对象）进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”， 类的两个不同实例就没有这种约束了。
  每个对象都有一个锁，且是唯一的。

• 类锁（又称全局锁，static synchronized）：该锁针对的是类，无论实例出多少个对象，那么线程依然共享该锁。
  static synchronized是限制多线程中该类的所有实例同时访问该类所对应的代码块。（实例.fun实际上相当于class.fun）

pulbic class Something(){
       // 非静态方法加锁
       public synchronized void isSyncA(){}
 
       public synchronized void isSyncB(){}
 
       // 静态方法加锁
       public static synchronized void cSyncA(){}
 
       public static synchronized void cSyncB(){}
 
}

假如有Something类的两个实例 Something x = new Something() 与
Something y = new Something() ，如果用多线程进行下述访问

• x.isSyncA()
  在多个线程同时访问该方法，显然同实例对象加锁，因此会线程同步，不会被同时访问，有约束。

  xThread1: 1
  xThread1: 2
  xThread1: 3
  xThread2: 1
  xThread2: 2
  xThread2: 3
  

• x.isSyncA()与x.isSyncB()
  这里就要说道，每个对象都有且只有一个锁。
  假设分配的一个对象空间（new了一个对象），里面有多个方法，相当于空间里面有多个小房间，如果我们把所有或部分的小房间都加锁（synchronized），因为这个对象只有一把钥匙，因此同一时间只能有一个人打开一个小房间，然后用完了还回去，再由JVM 去分配下一个获得钥匙的人。
  所以此处，都是对同一个实例的synchronized域访问，因此不能被同时访问，有约束。

• x.isSyncA()与y.isSyncA()
  不同的实例对象会生成不同的对象锁（对象锁对于不同的对象实例没有锁的约束），因此两者互不影响，可以同时访问（运行时成交替输出），无约束。

• x.cSyncA()与y.cSyncB()
x.cSyncA()与y.cSyncB()相当于是Something.cSyncA()与Something.cSyncB()。
  对于类锁，相当于将所有实例对象共享了这一唯一锁，因此即便是不同实例对象之间，仍然会被限制。所以不能被同时访问，有约束。

• x.isSyncA()与x.cSyncA()（相当于Something.cSyncA()）
  这是一种较为特殊的情况，加锁的实例对象方法与加锁的类方法由于锁定（lock）不同这一原因，各自管自己的，因此并无约束，可以同时被访问到，无约束。
  类锁和对象锁是两个不一样的锁，控制着不同的区域，两者互不干扰。
  在线程获得对象锁的同时，也可以获得该实例的类锁，即同时获得两个锁，这是允许的。

总结：

• 一个锁的是类对象，一个锁的是实例对象。
• 若类对象被lock，则类对象的所有同步方法（static synchronized func）全被lock。
• 若实例对象被lock，则该实例对象的所有同步方法（synchronized func）全被lock。

---

synchronized方法与synchronized代码块的区别

synchronized methods() {} 与 synchronized (this) {} 之间并没有什么区别。只是前者便于阅读理解，而后者可以更精确的控制冲突限制访问区域，有时候表现得更加高效。

synchronized代码块获得的是一个对象锁，锁住的同样是整个对象。

    public void test4() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
        System.out.println();
        synchronized (this) {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + " s: " + i);
            }
        }
    }

比如在上述代码中，假设有两个线程访问该方法。

• 当A线程访问对象的synchronized(this)代码块的时候，B线程依然可以访问对象方法中其余非synchronized块的部分。
• 当A线程进入对象的synchronized(this)代码块的时候，B线程如果要访问这段synchronized块，那么访问将会被阻塞。

// 运行结果
thread2 : 0
thread1 : 0
thread2 : 1
thread1 : 1
thread2 : 2
thread1 : 2


thread1 s: 0
thread1 s: 1
thread1 s: 2
thread2 s: 0
thread2 s: 1
thread2 s: 2

由上可知，从执行效率的角度考虑，有时候并不需要将整个方法都加上synchronized，而是可以采取synchronized代码块的方式，对会引起线程安全问题的那部分代码进行synchronized就可以了。

注：由上述知道，synchronized方法和synchronized代码块没有太大区别，所以假设线程A访问了对象的X方法中的synchronized代码块部分，线程B访问同一对象的Y方法中的synchronized方法/代码块，都会被堵塞。

synchronized(非this对象)

上述都是使用synchronized(this)的格式来同步代码块，但JAVA还支持对"任意对象"作为对象监视器来实现同步的功能。这个"任意对象"大多数是实例变量及方法的参数，使用格式为synchronized(非this对象)。

其实同理，锁住的不是当前实例对象，而是放入synchronized(非this对象)中的非this对象，即对该对象进行加锁。

优点：

如果在一个类中有很多synchronized方法，这时虽然能实现同步，但会受到阻塞，从而影响效率。

但如果同步代码块锁的是非this对象，则synchronized(非this对象)代码块中的程序与同步方法是异步的，不与其他锁this同步方法争抢this锁，大大提高了运行效率。

注：synchronized(非this对象)，这个对象如果是实例变量的话，指的是对象的引用，只要对象的引用不变，即使改变了对象的属性，运行结果依然是同步的。

参考：
Synchronized（对象锁）和Static Synchronized（类锁）的区别
java的静态方法加锁与一般方法加锁
java 多线程9 : synchronized锁机制 之 代码块锁