synchronized（class） 与 synchronized（this）区别

先上代码

public class SynchronizedTest {

	/**
	 * 锁住class对象
	 */
	public void synchronizedClass() {
		synchronized (SynchronizedTest.class) {
			System.out.println("synchronizedClass");
			try {
				Thread.sleep(10000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

	}

	/**
	 * 锁住方法，lock标记打在该实力上
	 */
	public synchronized void synchronizedMethod() {
		System.out.println("synchronizedMethod");
		try {
			Thread.sleep(8000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
	
	/**
	 * 锁住静态方法，lock标记打在该实力上
	 */
	public static synchronized void synchronizedStaticMethod() {
		System.out.println("synchronizedStaticMethod");
		try {
			Thread.sleep(8000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	/**
	 * 不会有影响，正常调用
	 */
	public void synchronizedMethod2WithNosynchronized() {
		System.out.println("synchronizedMethod2WithNosynchronized  no");
	}

	/**
	 * synchronizedMethod 已经锁住实例， 再加锁不成功
	 */
	public void synchronizedThis1() {
		synchronized (SynchronizedTest.this) {
			System.out.println("synchronizedThis1");
			try {
				Thread.sleep(15000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}

	/**
	 * synchronizedMethod 已经锁住实例， 再加锁不成功
	 */
	public void synchronizedThis2() {
		synchronized (this) {
			System.out.println("synchronizedThis2");
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

	/**
	 * @param args
	 * @throws InterruptedException
	 */
	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		final SynchronizedTest t = new SynchronizedTest();
		final SynchronizedTest t1 = new SynchronizedTest();
		//调用代码看下面
	}

}

1，第一组对比(在main中执行)

Thread th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				 t.synchronizedClass();
			}

		});
		th.start();

th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				t.synchronizedThis1();
			}

		});
		th.start();
		t.synchronizedMethod2WithNosynchronized();

结果如下：

synchronizedClass

synchronizedMethod2WithNosynchronized  no

synchronizedThis2

这个是基本同时间执行的

Java语法规定，任何线程执行同步方法、同步代码块之前，必须先获取对应的监视器。并且 监听器this 和 **.class 是不同的

this 是对用方法的对象本身 class 是该类本身(只有监听器相同锁才会起作用)

2，第二组对比

Thread th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				 t.synchronizedClass();
			}

		});
		th.start();

th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				 t.synchronizedStaticMethod();
			}

		});
		th.start();

这一个是synchronied(class) 一个是给static 方法加锁  会怎样执行呢？

测试结果是一个先执行结束后 另一执行  这是为什么呢?

因为 static 方法 和 class 一样都是锁的该类本身 是同一个监听器

3，第三组对比

th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				t.synchronizedThis1();
			}

		});
		th.start();
		t.synchronizedMethod2WithNosynchronized();

th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				 t.synchronizedThis2();
			}

		});
		th.start();

这组都是对象t(在main中声明的两个对象 t 和 t1)

这个由于二者锁的是同一个对象 一个执行完另一个才会执行（尽管是调用的不同的方法）

4，第四组对比

th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				t.synchronizedThis1();
			}

		});
		th.start();
		t.synchronizedMethod2WithNosynchronized();

th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
//				 t1.synchronizedMethod();
				 t.synchronizedMethod();
			}

		});
		th.start();

这组一个是this 一个是 非static 方法（但是调用方法的对象是同一个）
这组这个非静态方法 也是所得当前对象 所以一个执行完另一个才会执行（如果是不同的对象 如把这组的第二个 换成t1，结果就会各自执行 ）

5，第五组对比

	th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				t.synchronizedThis1();
			}

		});
		th.start();

th = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				 t1.synchronizedThis2();
			}

		});
		th.start();

这组是不同的两个对象
这组由于对象不同，所以会各自执行。