Java教程

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

本文主要是介绍Java每日一练05多线程6种方法实现交替打印输出前3种方法,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

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

  • 主方法
  • BlockingQueue阻塞队列实现
  • CyclicBarrier循环屏障实现
  • 自旋+让出CPU实现

主方法

/**
 * 主方法
 * @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();
            }
        }
    }
}
这篇关于Java每日一练05多线程6种方法实现交替打印输出前3种方法的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!