多线程顺序打印ABC

//通过一个prevChar控制互斥变量，当当前竞争锁失败的时候，便释放对象锁。

class PrintABC {

	private char prevChar = 'C';
	public synchronized boolean createA() {
		if (prevChar != 'C') {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			prevChar = 'A';
			System.out.println(prevChar);
			this.notifyAll();
			return true;
		}
		return false;
	}

	public synchronized boolean createB() {
		if (prevChar != 'A') {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			prevChar = 'B';
			System.out.println(prevChar);
			this.notifyAll();
			return true;
		}
		return false;
	}

	public synchronized boolean createC() {
		if (prevChar != 'B') {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} else {
			prevChar = 'C';
			System.out.println(prevChar);
			this.notifyAll();
			return true;
		}
		return false;
	}
}

public class MultiThreadPrintABC {

	static int maxSize = 3*50;
	static int count = 0;
	static PrintABC print = new PrintABC();

	static class ThreadA implements Runnable {

		@Override
		public void run() {
			while (count < maxSize) {
				if(print.createA()){
					count ++;
				}
			}
		}

	}

	static class ThreadB implements Runnable {
		@Override
		public void run() {
			while(count < maxSize){
				if(print.createB()){
					count++;
				}
			}
		}

	}

	static class ThreadC implements Runnable {

		@Override
		public void run() {
			while(count < maxSize){
				if(print.createC()){
					count++;
				}
			}
		}

	}

	public static void main(String[] args) throws InterruptedException {
		ThreadA a = new ThreadA();
		Thread threadA = new Thread(a);
		ThreadB b = new ThreadB();
		Thread threadB = new Thread(b);
		ThreadC c = new ThreadC();
		Thread threadC = new Thread(c);
		threadA.start();
		threadB.start();
		threadC.start();

	}

}

另外一个人的文章通过三个状态变量控制 点击打开链接