Java每日一练06多线程实现交叉打印输出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();
    }
}

可重入锁 + Condition实现

/**
 * 可重入锁 + Condition
 *
 * @author 驳壳毛瑟
 * @apiNote
 * 实现过程类似生产者消费者模式
 * signal
 * signal调用的前提是已经获得了lock锁
 * 并且必须放在lock和unlock之间
 * 通俗理解就是使得线程重新进入运行状态
 * 和wait和notify方法类似
 * 没什么难的
 */
class FooBar4 {
    private int n;

    public FooBar4(int n) {
        this.n = n;
    }

    Lock lock = new ReentrantLock(true);
    private final Condition foo = lock.newCondition();
    volatile boolean flag = true;

    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            lock.lock();
            try {
                while (!flag) {
                    foo.await();
                }
                printFoo.run();
                flag = false;
                foo.signal();
            } finally {
                lock.unlock();
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            lock.lock();
            try {
                while (flag) {
                    foo.await();
                }
                printBar.run();
                flag = true;
                foo.signal();
            } finally {
                lock.unlock();
            }
        }
    }
}

synchronized同步锁+唤醒实现

/**
 * synchronized同步锁+唤醒
 * @author 驳壳毛瑟
 * @apiNote 
 * 太简单，不想说
 */
class FooBar5 {
    private int n;
    // 标志位，控制执行顺序，true执行printFoo，false执行printBar
    private volatile boolean type = true;
    private final Object foo=  new Object(); // 锁标志

    public FooBar5(int n) {
        this.n = n;
    }
    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            synchronized (foo) {
                while(!type){
                    foo.wait();
                }
                printFoo.run();
                type = false;
                foo.notifyAll();
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            synchronized (foo) {
                while(type){
                    foo.wait();
                }
                printBar.run();
                type = true;
                foo.notifyAll();
            }
        }
    }
}

/**
 * 信号量实现
 * @author 驳壳毛瑟
 * @apiNote 
 */
class FooBar6 {
    private int n;
    private Semaphore foo = new Semaphore(1);
    private Semaphore bar = new Semaphore(0);
    public FooBar6(int n) {
        this.n = n;
    }

    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            foo.acquire();
            printFoo.run();
            bar.release();
        }
    }
    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            bar.acquire();
            printBar.run();
            foo.release();
        }
    }
}