用LockSupport解Leetcode1116并发题，请教下哪里出了问题

2020-06-12 01:43:49 222 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

[NVME] CMBLOC-Controller Memory Buffer Location CMBLOC-Controller Memory Buffer Location 阅读详情

原题链接：https://leetcode-cn.com/problems/print-zero-even-odd/

问题：
死磕了2天了，不弄明白切鸡儿。大概是在几百次运行后会有明显的同步问题导致结果错误，有时也会莫名其妙的阻塞住。不知道老哥们有何高见，换解法就不必了~

我的解法：
main方法测试用了输出重定向，然后获取打印值进行判断，和期望值不符则break。同时还依赖一个把类似Consumer函数封装成Runnable并try catch异常的接口，嫌麻烦可以自己写测试。

public class Solution1116 {



    static CountDownLatch cdl = new CountDownLatch(3);



    public static void main(String[] args) {

        ZeroEvenOdd zeo = new ZeroEvenOdd(9);

        

        // 重定向输出流相关操作

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        PrintStream ps = new PrintStream(baos);

        PrintStream old = System.out;

        System.setOut(ps);

        

        // 初始化线程和3个Runnable

        IntConsumer ic = System.out::print;

        ExecutorService es = Executors.newFixedThreadPool(3);

        Runnable r0 = ConsumerCatch.runnableWrap(zeo::zero, ic); // 需要ConsumerCatch接口的支持

        Runnable r1 = ConsumerCatch.runnableWrap(zeo::odd, ic);

        Runnable r2 = ConsumerCatch.runnableWrap(zeo::even, ic);

        while (true) {

            es.submit(r0);

            es.submit(r1);

            es.submit(r2);

            try {

                cdl.await(); // 阻塞主线程

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            

            // 打印并比对结果

            ps.flush();

            System.setOut(old);

            String s = baos.toString();

            System.out.println(s);

            if (!s.equals("010203040506070809")) {

                break;

            }

            

            // 全体重置

            baos.reset();

            cdl = new CountDownLatch(3);

            zeo.reset();

            System.setOut(ps); 

        }

    }



    private static class ZeroEvenOdd {



        private int n;

        private volatile int current = 1; // 弃用

        private AtomicInteger ai = new AtomicInteger(1);



        private volatile Thread t0 = null;

        private volatile Thread t1 = null;

        private volatile Thread t2 = null;



        public ZeroEvenOdd(int n) {

            this.n = n;

        }



        // 测试用，用来使该对象恢复到初始状态

        public void reset() {

            ai.set(1);

            t0 = null;

            t1 = null;

            t2 = null;

        }



        // printNumber.accept(x) outputs "x", where x is an integer.

        public void zero(IntConsumer printNumber) throws InterruptedException {

            t0 = Thread.currentThread();

            for (int i = 0; i < n; i++) {

                printNumber.accept(0);

                while (t1 == null || t2 == null) {} // 自旋保证初始化 + 内存屏障

                if ((ai.get() & 1) == 1) 

                    LockSupport.unpark(t1);

                else 

                    LockSupport.unpark(t2);

                if (i != n - 1)

                LockSupport.park();

            }

            Solution1116.cdl.countDown(); // 仅测试，用来给主线程放行

        }



        public void even(IntConsumer printNumber) throws InterruptedException {

            t2 = Thread.currentThread();

            for (int i = 0; i < n / 2; i++) {

                LockSupport.park();

                printNumber.accept(ai.getAndIncrement());

                LockSupport.unpark(t0);

            }

            Solution1116.cdl.countDown(); // 仅测试，用来给主线程放行

        }



        public void odd(IntConsumer printNumber) throws InterruptedException {

            t1 = Thread.currentThread();

            for (int i = 0; i < n - n / 2; i++) {

                LockSupport.park();

                printNumber.accept(ai.getAndIncrement());

                LockSupport.unpark(t0);

            }

            Solution1116.cdl.countDown(); // 仅测试，用来给主线程放行

        }

    }

}

main方法所依赖的接口：
主要是为了少写try catch，就整了一个

@FunctionalInterface

public interface ConsumerCatch<T>{



     static <T> Runnable runnableWrap(ConsumerCatch<T> ct, T t) {

         return () -> {

             try {

                 ct.accept(t);

             } catch (Exception e) {

                 e.printStackTrace();

             }

         };

    }



    static <T> Thread threadWrap(ConsumerCatch<T> ct, T t) {

        return new Thread(() -> {

            try {

                ct.accept(t);

            } catch (Exception e) {

                e.printStackTrace();

            }

        });

    }



    void accept(T t) throws Exception;

}