synchronized 与 static synchronized的区别

        面试过程中被问到了这个问题，当时虽然答对了、但是仍然属于一知半解状态，网上有详细的说明、以此为基础增加了自己的理解和测试。

        一个日本作者-结成浩的《java多线程设计模式》有这样的一个列子：

      

pulbic class Something(){
    public synchronized void isSyncA(){}
    public synchronized void isSyncB(){}
    public static synchronized void cSyncA(){}
    public static synchronized void cSyncB(){}
}

       加入Something类的两个实例a、b，被x和y两个线程调用、能否同时访问

a. x.isSyncA()与x.isSyncB() 
b. x.isSyncA()与y.isSyncA()
c. x.cSyncA()与y.cSyncB()
d. x.isSyncA()与Something.cSyncA()

       a.  同一实例调用不同被同步的方法、同步起作用，无法同时访问

       b.  不同实例调用同一被同步的方法、同步无效，可以同时访问

       c.  不同实例调用同一被同步的静态方法、同步有效，无法同时访问

       d.  实例调用被同步的方法与类调用静态方法、同步无效，可以同时访问

       

       详解：同步过程即lock使用权的竞争，而这lock是属于单个实例的、即每个实例有一把属于自己的lock，每个类也有一把属于自己的lock。a里面x实例的同步方法竞争x的lock、因此同步有效。b里面x实例的同步方法竞争x的lock，y实例的同步方法竞争y的lock，由于竞争的不是同一把锁、因此同步无效。c里面x实例的静态同步方法竞争Something类的lock，y实例的静态同步方法也竞争Something类的lock，因此同步有效。d里面x实例的同步方法竞争x的lock，y实例的静态同步方法竞争Something类的lock，非同一把锁、因此同步无效。因此、同步是否有效关键在于两者竞争的lock是否是同一把，记住锁属于对象本身就行了。

       在添加synchronized代码块的时候，注意同步锁的粒度、尽量保证粒度的最小化，保证代码的高效率。

 

       c、d的测试实例如下：观察打印结果 判定同步是否生效。

package synchronizedTest;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SynchronizedTest {
	public static int i = 0;
	
	public synchronized void add() {
		i++;
		print();
	}
	
	public static synchronized void staticAdd() {
		i++;
		print();
	}
	
	public static synchronized void staticAddB() {
		i++;
		print();
	}
	
	public static void print() {
		System.out.println(Thread.currentThread().getName() + ":" + i);
	}
	
	public static void main(String[] args) throws InterruptedException {
		ExecutorService pool = Executors.newFixedThreadPool(20);
		final CountDownLatch ready = new CountDownLatch(20);
		final CountDownLatch start = new CountDownLatch(1);
		final CountDownLatch end = new CountDownLatch(20);
		final SynchronizedTest s = new SynchronizedTest();
		final SynchronizedTest b = new SynchronizedTest();
		
		for(int j = 0; j < 20; j++) {
			pool.execute(new Runnable() {
				public void run() {
					ready.countDown();
					try {
						System.out.println(i); //帮助理解CountDownLatch
						start.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					s.add();
					staticAdd();
				//	s.staticAdd(); 测试c的代码
				//	b.staticAddB();
					end.countDown();
				}
			});
		}
		
		ready.await();
		System.out.println("read to exception...");
		start.countDown();
		end.await();
		System.out.println("exceute completed close...");
		pool.shutdown();
	}
}