synchronized取得的锁都是对象锁

public class MultiThread {

	private int num = 0;
	
	/** static */
	public synchronized void printNum(String tag){
		try {
			
			if(tag.equals("a")){
				num ++;
				System.out.println("tag a, set num over!");
				Thread.sleep(1000);
			} else {
				num--;
				System.out.println("tag b, set num over!");
			}
			
			System.out.println("tag " + tag + ", num = " + num);
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	//注意观察run方法输出顺序
	public static void main(String[] args) {
		
		//俩个不同的对象,这里获得的是两把不同的锁
		final MultiThread m1 = new MultiThread();
		final MultiThread m2 = new MultiThread();
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				m1.printNum("a");
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override 
			public void run() {
				m2.printNum("b");
			}
		});		
		
		t1.start();
		t2.start();
		
	}
输出结果：tag b, set num over!
          tag a, set num over!
          tag b, num = -1
          tag a, num = 1  没有顺序性，可见t2并没有排队等t1执行完毕。
另一种情况：当把num变量和方法同时加上static时，即在静态方法上加synchronized关键字，表示锁定.class类，
类一级别的锁（独占.class类），则两对象获得是同一把锁。此时输出结果：
输出结果：tag a, set num over!
          tag a, num = 1
          tag b, set num over!
          tag b, num = 0  线程t1执行完毕时，释放锁，给排队的t2线程，结果顺序输出。
总结：关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁，
 所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock）。此时new对
象获得的锁是互不影响的。而类一级别的锁是独占的，多个对象获得锁是同一把，存在竞争。