循环打印ABC

package com.wly;

import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.ReentrantLock;

public class LockMethod {
    private static int state = 0;
    private static ReentrantLock lock = new ReentrantLock();
    static class ThreadA extends Thread {
        @Override
        public void run() {
            for (int i=1; i<=100;) {
                try{
                    lock.lock();
                    while (state % 3 ==0) {
                        System.out.println("A");
                        state++;
                        i++;
                    }
                }finally {
                    lock.unlock();
                }
            }
        }
    }

    static class ThreadB extends Thread {
        @Override
        public void run() {
            for (int i=1; i<=100;) {
                try{
                    lock.lock();
                    while (state % 3 ==1) {
                        System.out.println("B");
                        state++;
                        i++;
                    }
                }finally {
                    lock.unlock();
                }
            }
        }
    }

    static class ThreadC extends Thread {
        @Override
        public void run() {
            for (int i=1; i<=100;) {
                try{
                    lock.lock();
                    while (state % 3 ==2) {
                        System.out.println("C");
                        state++;
                        i++;
                    }
                }finally {
                    lock.unlock();
                }
            }
        }
    }
    public static void main(String[] args) {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}

信号量

public class Main {
    public static Semaphore semaphoreA = new Semaphore(1);
    public static Semaphore semaphoreB = new Semaphore(0);
    public static Semaphore semaphoreC = new Semaphore(0);
    static class ThreadA extends Thread{
        @Override
        public void run() {
            try{
                for(int i=1; i<=100; i++) {
                    semaphoreA.acquire();
                    System.out.println("A");
                    semaphoreB.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
    static class ThreadB extends Thread {
        @Override
        public void run() {
            try{
                for(int i=1; i<=100; i++) {
                    semaphoreB.acquire();
                    System.out.println("B");
                    semaphoreC.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    static class ThreadC extends Thread {
        @Override
        public void run() {
            try{
                for(int i=1; i<=100; i++) {
                    semaphoreC.acquire();
                    System.out.println("C");
                    semaphoreA.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        new ThreadA().start();
        new ThreadB().start();
        new ThreadC().start();
    }
}