Java Thread顺序打印123----synchronized(1)

上篇文章介绍了如何使用lock进行顺序打印123。

本文使用另外一种同步方式synchronized关键字进行并发控制。synchronized关键字可以控制对象的锁，也可以控制类的锁。

synchronized关键字操作对象的固有锁，也就是对象的内置锁。

当多个进程需要竞争同一个资源时，可以使用synchronized对象的方式，控制线程的竞争访问，因为同时只能有一个线程获得对象的锁。

当一个线程获得对象锁以后，其他的线程将进入等待状态，它们会等待对象锁的释放。

如下图所示：

程序如下，类似之前lock的方式

import java.util.concurrent.TimeUnit;

public class PrintOneTwo {
	static int state = 1;
	static Object obj = new Object();

	static Thread One = new Thread(new Runnable() {

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (!One.isInterrupted()) {
				synchronized (obj) {
					if (state % 3 == 1) {
						try {
							TimeUnit.MILLISECONDS.sleep(200);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
							break;
						}
						System.out.print(1);
						state++;
					}
				}
			}
		}

	});
	static Thread Two = new Thread(new Runnable() {

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (!Two.isInterrupted()) {
				synchronized (obj) {
					if (state % 3 == 2) {
						try {
							TimeUnit.MILLISECONDS.sleep(200);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
							break;
						}
						System.out.print(2);
						state++;
					}
				}
			}
		}

	});
	static Thread Thr = new Thread(new Runnable() {

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (!Thr.isInterrupted()) {
				synchronized (obj) {
					if (state % 3 == 0) {
						try {
							TimeUnit.MILLISECONDS.sleep(200);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
							break;
						}
						System.out.print(3);
						state++;
					}
				}
			}
		}

	});

	/**
	 * @param args
	 * @throws InterruptedException
	 */
	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		One.start();
		Two.start();
		Thr.start();
		TimeUnit.MILLISECONDS.sleep(10000);
		One.interrupt();
		Two.interrupt();
		Thr.interrupt();
	}

}

通过synchronized控制同一个对象，3个线程竞争对象锁，上图中Thread-1获得锁，那么object的owner就是它，它将对state进行操作。

其他两个线程都是wait状态，等待object固有锁的释放。