交替打印奇偶的常见实现方式

关于交替打印奇偶数的代码实现网上已经很多了，这篇文章并不是提出新的实现方式，而是对网上现有的实现方式进行一个汇总，闲话不多说，直接上代码

基于volatile的实现

public class Main {

    private static volatile int num = 0;

    //是否打印奇数
    private static volatile boolean isPrintOdd = false;

    public static void main(String[] args) {

        //打印的最大数上限
        final int MAX_NUM = 100;

        Thread t0 = new Thread(() -> {

            while (num <= MAX_NUM) {

                if (isPrintOdd) {
                    continue;
                }

                System.out.println(Thread.currentThread().getName() + "\t" + num);
                num += 1;

                isPrintOdd = !isPrintOdd;
            }

        }, "t0");

        Thread t1 = new Thread(() -> {

            while (num <= MAX_NUM) {

                if (!isPrintOdd) {
                    continue;
                }

                System.out.println(Thread.currentThread().getName() + "\t" + num);
                num += 1;

                isPrintOdd = !isPrintOdd;
            }
        }, "t1");

        t0.start();

        t1.start();
    }
}

基于wait/notify机制的实现

public class Main {

    private static volatile int num = 0;

    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        //打印的最大数上限
        final int MAX_NUM = 100;

        Thread t0 = new Thread(() -> {

            try {

                while (num <= MAX_NUM) {
                    synchronized (lock) {
                        System.out.println(Thread.currentThread().getName() + "\t" + num++);

                        lock.notifyAll();
                        lock.wait();
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

        }, "t0");

        Thread t1 = new Thread(() -> {

            try {

                while (num <= MAX_NUM) {
                    synchronized (lock) {
                        System.out.println(Thread.currentThread().getName() + "\t" + num++);

                        lock.notifyAll();
                        lock.wait();
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

        }, "t1");

        t0.start();

        //延迟启动打印奇数线程
        TimeUnit.MILLISECONDS.sleep(100);

        t1.start();
    }
}

基于Lock/Condition机制实现

    private static volatile int num = 0;

    private static ReentrantLock lock = new ReentrantLock();

    //奇数锁条件
    private static Condition oddCondition = lock.newCondition();

    //偶数锁条件
    private static Condition evenCondition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {

        //打印的最大数上限
        final int MAX_NUM = 100;

        Thread t0 = new Thread(() -> {

            while (num <= MAX_NUM) {
                try {

                    lock.lock();

                    System.out.println(Thread.currentThread().getName() + "\t" + num++);

                    oddCondition.signalAll();

                    evenCondition.await();

                } catch (Exception e) {
                    e.printStackTrace();
                } finally {

                    lock.unlock();

                }
            }

        }, "t0");

        Thread t1 = new Thread(() -> {

            while (num <= MAX_NUM) {
                try {
                    lock.lock();

                    System.out.println(Thread.currentThread().getName() + "\t" + num++);

                    evenCondition.signalAll();

                    oddCondition.await();

                } catch (Exception e) {
                    e.printStackTrace();
                }finally {

                    lock.unlock();

                }
            }

        }, "t1");

        t0.start();

        //延迟启动打印奇数线程
        TimeUnit.MILLISECONDS.sleep(100);

        t1.start();
    }