多线程交替打印数字

 Thread.yield()

    private final AtomicInteger count = new AtomicInteger(0);

    private volatile int state;

    public void first() {
        for (int i = 0; i < 5; i++) {
            while (state != 0) {
                Thread.yield();
            }
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            state = 1;
        }
    }

    public void second() {
        for (int i = 0; i < 5; i++) {
            while (state != 1) {
                Thread.yield();
            }
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            state = 2;
        }
    }

    public void third() {
        for (int i = 0; i < 5; i++) {
            while (state != 2) {
                Thread.yield();
            }
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            state = 0;
        }
    }

 Semaphore 

    private final AtomicInteger count = new AtomicInteger(0);

    private final Semaphore first = new Semaphore(1);
    private final Semaphore second = new Semaphore(0);
    private final Semaphore third = new Semaphore(0);

    public void first() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            first.acquire();
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            second.release();
        }
    }

    public void second() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            second.acquire();
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            third.release();
        }
    }

    public void third() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            third.acquire();
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            first.release();
        }

 CountDownLatch

    private final AtomicInteger count = new AtomicInteger(0);

    private CountDownLatch first = new CountDownLatch(0);
    private CountDownLatch second = new CountDownLatch(1);
    private CountDownLatch third = new CountDownLatch(1);

    public void first() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            first.await();
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            first = new CountDownLatch(1);
            second.countDown();
        }
    }

    public void second() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            second.await();
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            second = new CountDownLatch(1);
            third.countDown();
        }
    }

    public void third() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            third.await();
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            third = new CountDownLatch(1);
            first.countDown();
        }
    }

 LockSupport

 

    private final AtomicInteger count = new AtomicInteger(0);

    private Map<String, Thread> map = new ConcurrentHashMap<>(4);

    private volatile int state;

    public void first() throws InterruptedException {
        map.put("first", Thread.currentThread());
        for (int i = 0; i < 5; i++) {
            while (state != 0) {
                LockSupport.park();
            }
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            state = 1;
            LockSupport.unpark(map.get("second"));
        }
    }

    public void second() throws InterruptedException {
        map.put("second", Thread.currentThread());
        for (int i = 0; i < 5; i++) {
            while (state != 1) {
                LockSupport.park();
            }
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            state = 2;
            LockSupport.unpark(map.get("third"));
        }
    }

    public void third() throws InterruptedException {
        map.put("third", Thread.currentThread());
        for (int i = 0; i < 5; i++) {
            while (state != 2) {
                LockSupport.park();
            }
            for (int j = 0; j < 5; j++) {
                System.out.println(
                        Thread.currentThread().getName() + "-" + count.incrementAndGet());
            }
            state = 0;
            LockSupport.unpark(map.get("first"));
        }
    }

ReentrantLock + Condition

    private final AtomicInteger count = new AtomicInteger(0);

    private final Lock lock = new ReentrantLock();
    private final Condition first = lock.newCondition();
    private final Condition second = lock.newCondition();
    private final Condition third = lock.newCondition();

    private volatile int state;

    public void first() throws InterruptedException {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++) {
                while (state != 0) {
                    first.await();
                }
                for (int j = 0; j < 5; j++) {
                    System.out.println(
                            Thread.currentThread().getName() + "-" + count.incrementAndGet());
                }
                state = 1;
                second.signal();
            }
        } finally {
            lock.unlock();
        }
    }

    public void second() throws InterruptedException {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++) {
                while (state != 1) {
                    second.await();
                }
                for (int j = 0; j < 5; j++) {
                    System.out.println(
                            Thread.currentThread().getName() + "-" + count.incrementAndGet());
                }
                state = 2;
                third.signal();
            }
        } finally {
            lock.unlock();
        }
    }

    public void third() throws InterruptedException {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++) {
                while (state != 2) {
                    third.await();
                }
                for (int j = 0; j < 5; j++) {
                    System.out.println(
                            Thread.currentThread().getName() + "-" + count.incrementAndGet());
                }
                state = 0;
                first.signal();
            }
        } finally {
            lock.unlock();
        }
    }

 

标签：count,Thread,int,打印,++,private,交替,state,多线程
来源： https://blog.csdn.net/liukezheng3/article/details/122197926