Java每日一练05多线程6种方法实现交替打印输出前3种方法

主方法

/**
 * 主方法
 * @author 驳壳毛瑟
 */
class FooBarTest {
    /*
     * 需求：
     *      两个不同的线程将会共用一个FooBar实例
     *      线程 A 将会调用 foo() 方法
     *      线程 B 将会调用 bar() 方法
     *      请设计修改程序，以确保"foobar"被输出n次
     */
    public static void main(String[] args) {
        FooBar fooBar = new FooBar(3); // foobar交替打印了3次

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    fooBar.foo(new Runnable() {
                        @Override
                        public void run() {
                            System.out.print("foo");
                        }
                    });
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    fooBar.bar(new Runnable() {
                        @Override
                        public void run() {
                            System.out.print("bar\n");
                        }
                    });
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
    }
}

BlockingQueue阻塞队列实现

/**
 * BlockingQueue阻塞队列实现
 * @author 驳壳毛瑟
 * @apiNote
 * put
 * 会向指定阻塞队列里面放入1个元素，当阻塞队列满时，程序会陷入阻塞，直到空出1个位置
 * take
 * 会向指定阻塞队列里面取出1个元素，当阻塞队列空时，程序会陷入阻塞，直到放入1个位置
 */
class FooBar {
    /*
     * 私有成员属性n
     * 规定了foobar需要交叉打印几次
     */
    private int n;
    private BlockingQueue<Integer> bar = new LinkedBlockingQueue<>(1);
    private BlockingQueue<Integer> foo = new LinkedBlockingQueue<>(1);
    public FooBar(int n) {
        this.n = n;
    }

    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            foo.put(i);
            printFoo.run(); // 输出foo
            bar.put(i);
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            bar.take();
            printBar.run(); // 输出bar
            foo.take();
        }
    }

    /*
     * 存在2个线程
     * foo线程执行foo方法
     * bar线程执行bar方法
     *
     * 程序运行流水线如下
     */
}

CyclicBarrier循环屏障实现

/**
 * CyclicBarrier循环屏障实现
 * @author 驳壳毛瑟
 * @apiNote
 * await 线程1和线程2都到达第一个栅栏后才能够继续运行
 * 如果线程1先到线程2后到，则线程1需要等待线程2到达栅栏处
 * 然后两个线程才能继续运行
 */
class FooBar2 {
    private int n;

    public FooBar2(int n) {
        this.n = n;
    }
    // 设置2层屏障
    CyclicBarrier cb = new CyclicBarrier(2);
    // 线程安全在boolean上生效，一个线程修改boolean值，另外一个线程会立即得到修改后的boolean值
    volatile boolean fin = true;

    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            while(!fin); // while循环内部为false，会继续执行下面的代码，程序不会卡在这里
            printFoo.run();
            fin = false;
            try {
                cb.await();
            } catch (BrokenBarrierException e) {}
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            try {
                cb.await();
            } catch (BrokenBarrierException e) {}
            printBar.run();
            fin = true;
        }
    }
}

自旋+让出CPU实现

/**
 * 自旋+让出CPU
 * @author 驳壳毛瑟
 * @apiNote 
 * 没什么可以解释的，很容易理解
 */
class FooBar3 {
    private int n;
    public FooBar3(int n) {
        this.n = n;
    }

    volatile boolean permitFoo = true;

    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; ) {
            if (permitFoo) {
                printFoo.run();
                i++;
                permitFoo = false;
            } else {
                Thread.yield();
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; ) {
            if (!permitFoo) {
                printBar.run();
                i++;
                permitFoo = true;
            } else {
                Thread.yield();
            }
        }
    }
}