多线程协作demo

启动两个线程, 一个输出1,3,5,7,9....99，另一个输出2，4，6，8....100，最后在terminal中输出1,2,3,4,5,6.....100

java 线程实现

/**
         * 多线程并发的时候需要通过一个锁来进行wait和notify控制线程的唤醒和等待
         */
        Object lock = new Object();

        /**
         * lambda代码块只能操作lambda代码块外的final变量,但是有时候又需要改变这个变量,
         * 所以通过final数组来规避这个问题。
         */
        final Thread[] threads = new Thread[2];

        /**
         * 当两个打印线程结束之后main线程退出
         */
        CountDownLatch countDownLatch = new CountDownLatch(2);

        threads[1] = new Thread(() -> {
            for (int i = 2; i <= 100; i += 2) {
                System.out.println(i);
                /**
                 * wait, notify, notifyAll 等方法需要在同步代码块中执行以保证并发安全。
                 */
                synchronized (lock) {
                    try {
                        /**
                         *唤醒thread[0]
                         */
                        lock.notifyAll();
                        if (i != 100) {
                            /**
                             * 本线程进入等待状态，释放cpu
                             */
                            lock.wait();
                        }

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            countDownLatch.countDown();
        });


        threads[0] = new Thread(() -> {
            for (int i = 1; i < 100; i += 2) {
                System.out.println(i);
                synchronized (lock) {
                    try {
                        /**
                         * 当i==1时代表thread[1]尚未开始启动
                         * 当i!=1时唤醒thread[1]
                         * 然后本线程进入等待状态释放cpu
                         */
                        if (i == 1) {
                            threads[1].start();
                        } else {
                            lock.notifyAll();
                        }
                        if (i != 99) {
                            lock.wait();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            countDownLatch.countDown();
        });

        /**
         * 启动thread[0]
         */
        threads[0].start();

        /**
         * main线程进入等待状态,当thread[0]和thread[1]的任务执行完成之后main线程被唤醒
         */
        countDownLatch.await();
        System.out.println("两个线程通过notify和wait实现循环打印100以内的数");

golang 协程实现

协程是用户级别的线程。在 java 中程序调度的基本单位是线程，java的线程和操作系统的线程是一一对应的,线程的调度是由操作系统内核完成的。golang中提供了协程来实现并发，多个协程运行在一个操作系统的线程上,协程的调度由用户态代码来实现，因而协程序更加轻量级。

a := make(chan bool, 1)
    b := make(chan bool)
    Exit := make(chan bool)

    //  <- chan 当chan中没有数据时会阻塞
    //  a <- true 往chan a 中放入放入一个值,此时阻塞的协程开始执行
    //  go func 启动一个协程
    go func() {
        for i := 1; i < 100; i += 2 {
            if ok := <-a; ok {
                fmt.Println(i)
                b <- true
            }
        }

    }()

    go func() {
        for i := 2; i <= 100; i += 2 {
            if ok := <-b; ok {
                fmt.Println(i)
                a <- true
            }
        }
        // 循环打印结束,主协程退出
        close(Exit)
    }()

    fmt.Println("end")

    a <- true
    _ := <-Exit