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