夯实基础:Java与Go两种模式下的多线程协作小demo

原文： https://studygolang.com/articles/18107

启动两个线程, 一个输出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