以前一直對多執行緒這一塊很模糊，平時工作中也很少用到（技術太渣），閒來無事就寫了一下面試經常會讓手寫的迴圈列印。

兩個執行緒中傳入了同一個物件，所以如果一個執行緒加鎖之後，另一個執行緒就不可以訪問該物件所擁有的所有同步方法，就是用這種思想，實現了下面的迴圈列印。

1、用Lock實現

package com.cn;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
	Lock lock = new ReentrantLock();
	Condition c1 = lock.newCondition();
	int status = 1;
	public static void main(String[] args) {
		LockTest lockTest = new LockTest();
		Run1 r1 = new Run1(lockTest);
		Run2 r2 = new Run2(lockTest);
		new Thread(r1).start();
		new Thread(r2).start();

	}
	
	static class Run1 implements Runnable{
		private LockTest lockTest;
		public Run1(LockTest lockTest) {
			this.lockTest = lockTest;
		}
		@Override
		public void run() {
			for (int i = 0; i < 5; i++) {
				lockTest.printA();
			}
		}
	}
	
	static class Run2 implements Runnable{
		private LockTest lockTest;
		public Run2(LockTest lockTest) {
			this.lockTest = lockTest;
		}
		@Override
		public void run() {
			for (int i = 0; i < 5; i++) {
				lockTest.printB();
			}
		}
	}
	
	public void printA() {
		try {
			lock.lock();
			while (status != 1) {
				try {
					c1.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("A");
			status = 2;
			c1.signal();
		} finally {
			lock.unlock();
		}
	}
	public void printB() {
		try {
			lock.lock();
			while (status != 2) {
				try {
					c1.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("B");
			status = 1;
			c1.signal();
		} finally {
			lock.unlock();
		}
	}

}
 

2、用synchronized實現

package com.cn;

public class ThreadTest {
	private int status = 1;
	
	public static void main(String[] args) {
		ThreadTest t = new ThreadTest();
		ThreadOne t1 = new ThreadOne(t);
		ThreadTwo t2 = new ThreadTwo(t);
		new Thread(t1, "thread1").start();
		new Thread(t2, "thread2").start();
	}
	
	static class ThreadOne implements Runnable{
		private ThreadTest threadTest;
		public ThreadOne(ThreadTest threadTest) {
			this.threadTest = threadTest;
		}
		
		@Override
		public void run() {
			for (int i = 0; i < 5; i++) {
				threadTest.printA();
			}
		}
	}
	
	static class ThreadTwo implements Runnable{
		private ThreadTest threadTest;
		public ThreadTwo(ThreadTest threadTest) {
			this.threadTest = threadTest;
		}
		
		@Override
		public void run() {
			for (int i = 0; i < 5; i++) {
				threadTest.printB();
			}
		}
	}
	
	public void printA(){
		synchronized (this) {
			while (status != 1) {
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("A");
			status = 2;
			this.notifyAll();
		}
	}
	public void printB(){
		synchronized (this) {
			while (status != 2) {
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("B");
			status = 1;
			this.notifyAll();
		}
	}
}
 

輸出結果為：