交替打印ABC

ReentrantLock，配合Condition

public class PrintABC {
    private int signal;// 还是需要通过信号量控制abc的输出顺序

    Lock lock = new ReentrantLock(); // 只有一个锁
    Condition a = lock.newCondition();// 多个condition
    Condition b = lock.newCondition();
    Condition c = lock.newCondition();

    public void printA() {// 去掉了synchronized，取而代之的是reentrantlock的lock和unlock。
        lock.lock();
        while (signal != 0) {
            try {
                a.await();// 释放cpu的执行资格和执行权，同时释放锁
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(600);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("A");
        signal++;
        b.signal();// 唤醒printB
        lock.unlock();
    }

    public void printB() {
        lock.lock();
        while (signal != 1) {
            try {
                b.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(600);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("B");
        signal++;
        c.signal();//唤醒printC
        lock.unlock();
    }

    public void printC() {
        lock.lock();
        while (signal != 2) {
            try {
                c.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(600);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("C");
        signal = 0;
        a.signal(); //唤醒printA
        lock.unlock();
    }

    public static void main(String[] args) {
        PrintABC printABC = new PrintABC();
        A a = new A(printABC);
        B b = new B(printABC);
        C c = new C(printABC);
        new Thread(a).start();
        new Thread(b).start();
        new Thread(c).start();

    }
}

class A implements Runnable {
    private PrintABC printABC;

    public A(PrintABC printABC) {
        this.printABC = printABC;
    }

    @Override
    public void run() {
        while (true) {
            printABC.printA();
        }
    }
}

class B implements Runnable {
    private PrintABC printABC;

    public B(PrintABC printABC) {
        this.printABC = printABC;
    }

    @Override
    public void run() {
        while (true) {
            printABC.printB();
        }
    }
}

class C implements Runnable {
    private PrintABC printABC;

    public C(PrintABC printABC) {
        this.printABC = printABC;

    }

    @Override
    public void run() {
        while (true) {
            printABC.printC();
        }
    }
}

synchronized

public class PrintABC {

	private int signal = 0;//通过信号量控制abc的输出顺序

    /**
     * signal = 0 的时候打印A，signal++
     */
    public synchronized void printA() {//加锁使用wait通信，同时保证了信号量的内存可见性
		while (signal != 0) {
			try {
				wait();//释放cpu的执行资格和执行权，同时释放锁
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
        try {
            Thread.sleep(600);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("A");
		signal++;
		notifyAll();
	}

    /**
     * signal = 1 的时候打印B，signal++
     */
	public synchronized void printB() {
		while (signal != 1) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
        try {
            Thread.sleep(600);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
		System.out.println("B");
		signal++;
		notifyAll();
	}

    /**
     * signal = 2 的时候打印C，signal = 0
     */
	public synchronized void printC() {
		while (signal != 2) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
        try {
            Thread.sleep(600);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
		System.out.println("C");
		signal = 0;
		notifyAll();
	}

	public static void main(String[] args) {
		PrintABC printABC = new PrintABC();
		A a = new A(printABC);
		B b = new B(printABC);
		C c = new C(printABC);
		new Thread(a).start();
		new Thread(b).start();
		new Thread(c).start();

	}

}

class A implements Runnable {
	private PrintABC printABC;

	public A(PrintABC printABC) {
		this.printABC = printABC;
	}

	@Override
	public void run() {
		while (true) {
			printABC.printA();
		}
	}
}

class B implements Runnable {
	private PrintABC printABC;

	public B(PrintABC printABC) {
		this.printABC = printABC;
	}

	@Override
	public void run() {
		while (true) {
			printABC.printB();
		}
	}
}

class C implements Runnable {
	private PrintABC printABC;

	public C(PrintABC printABC) {
		this.printABC = printABC;
	}

	@Override
	public void run() {
		while (true) {
			printABC.printC();
		}
	}
}