Java多线程同步 – synchronized 用法

1.      利用类对象进行同步

当两个线程访问同一个类对象时，发生竞争。同步加锁的是对象，而不是代码。

package thrds;

public class FiveThread {

	public static void main(String args[])
	{
		ThTst obj = new ThTst();
		Thread t1 = new Thread(obj);  // 两个线程用同一个对象，发生互斥（属于对象互斥）
		Thread t2 = new Thread(obj);

		t1.start();
		t2.start();
	}

}

class ThTst extends Thread {

	public void run() {
		tst();
	}

	synchronized void tst()
	{
		System.out.println(Thread.currentThread().getId() + " in");

		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
					e.printStackTrace();
		}

		System.out.println(Thread.currentThread().getId() + " out");
	}
}

输出结果：
15 in
15 out
14 in
14 out

如果将上述 main函数中改为：
Thread t1 = new Thread(new ThTst());  // 使用两个对象，不会发生竞争
Thread t2 = new Thread(new ThTst());

输出结果：
17 in
15 in
15 out
17 out

2.      使用类定义和 对象 进行同步（类.class）

即使两个线程分别访问不同的对象，也会发生竞争。加锁的是代码段。

因为一个类的类定义只有一个，因此，到加锁的地方，只能有一个线程进去执行。

注意：null不可用来作为同步对象。

package thrds;

public class SixThread {

	public static void main(String args[])
	{
		Thread t1 = new Thread(new ThTst2());
		Thread t2 = new Thread(new ThTst2());

		t1.start();
		t2.start();
	}

}

class ThTst2 extends Thread {

	private static Integer iObj = 9;

	public void run() {
		tst();
	}

	synchronized void tst()
	{
		synchronized (ThTst2.class) { //这里可用任何类类型，如 String.class, Integer.class  或使用 其他对象如iObj 也是一样的

			System.out.println(Thread.currentThread().getId() + " in");

			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			System.out.println(Thread.currentThread().getId() + " out");
		}
	}
}

输出结果：
14 in
14 out
16 in
16 out

3.      2中使用对象同步，用来同步的对象，可由参数传入。这样，可提供更多的灵活性，程序员可以控制哪几个线程竞争同一个对象。（在设计时可参考）

package thrds;

import org.omg.CORBA.INV_OBJREF;

public class SevenThread {

	public static void main(String args[])
	{
		ThTst3 tObj1 = new ThTst3();
		ThTst3 tObj2 = new ThTst3();

		String lock = new String("lock");
		tObj1.setLock(lock);
		tObj2.setLock(lock);

		Thread t1 = new Thread(tObj1);
		Thread t2 = new Thread(tObj2);

		t1.start();
		t2.start();
	}

}

class ThTst3 extends Thread {

	private String lock = null;

	@Override
	public void run() {
		tst();
	}

	synchronized void tst()
	{
		synchronized (lock) { //同步对象由参数传入

			System.out.println(Thread.currentThread().getId() + " in");

			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}

			System.out.println(Thread.currentThread().getId() + " out");
		}
	}

	void setLock(String lock)
	{
		this.lock = lock;
	}
}

输出结果：
15 in
15 out
16 in
16 out

synchronized关键字，多线程在同步时，需要看用来同步的对象（包括类定义）是不是唯一的。只有对象是唯一的时候，才会发生互斥。