1 简介
我们通过可重入锁在python的同步线程中实现了 对线程异步的操作， 一个可重入锁必须由获得它的线程来释放。 一旦一个线程获得了一个可重入锁，同一个线程可以再次获得它而不阻塞。
而该线程每获得一次锁，就必须释放一次锁。 获取的锁都必须释放一次。 它获取一个信号，将内部计数器递减1。
当调用没有参数时：如果内部计数器在进入时大于 0，则将其递减1并立即返回。
如果它是零则阻塞，等待其他线程调用release()，使其大于零。
这是以适当的互锁方式进行的，因此 如果多个acquisition()调用被阻塞，release()将正好唤醒其中一个唤醒它们中的一个。
实现可能会随机选择一个，所以被阻塞的线程被唤醒的顺序为 唤醒被阻塞线程的顺序不应该被依赖。
在这种情况下，没有在这种情况下没有返回值。
当调用阻塞设置为 "true "时，做与调用 "无参数 "时相同的事情。 不带参数的情况下做同样的事情，并返回true。
当调用时将阻塞设置为false时，不要阻塞。如果一个没有参数的调用会阻塞，立即返回false；
否则，做与无参数调用时相同的事情，并返回true。
当调用时的超时时间不是None，它将阻塞最多 超时秒。
如果在这个时间段内，获取没有成功完成时间间隔内没有成功完成，则返回false。 否则返回true。
可重入锁允许线程递归获取锁，每次获取后需相应释放。在Python中，acquire()和release()管理内部计数器，确保正确同步。线程安全的队列在生产者（同步存入）和消费者（异步取出）间协调数据传输，展示出不同线程行为导致的输出无序性。Go中，goroutines作为轻量级协程，通过channel进行同步通信。
2 同步存入和异步取出
使用 入口判断 代码执行 同步还是异步，producer 同步 存入
def producer(q, n):
for i in range(n):
q.put(i)
q.put(None)
q = Queuey(2)
启用线程同步存入
Thread(target=producer, args=(q, 10)).start()
time.sleep(1)
启用线程循环，异步取出
loop.run_until_complete(aconsumer(q))
运行时的输出，可以看到由于同步线程和异步线程的不同操作 输出的无序的：
put sync item: 0
put sync item: 1
put sync item: 2
get async item
Async Got: 0
get async item
put sync item: 3
Async Got:put sync item: 14
get async item
Async Got:
put sync item: 2
get async item
5
Async Got: put sync item: 3
6
get async item
Async Got: put sync item: 4
7
get async item
Async Got: put sync item: 5
8
get async item
Async Got: put sync item: 6
9
get async item
Async Got:put sync item: 7None
get async item
Async Got: 8
get async item
Async Got: 9
3 同步存，异步取：go的简单例子
同步存入时需要注意，把channel的长度与调用者匹配
func SyncPutin(n int) {
AsyncQueue = make(chan int, n)
for i := 0; i < n; i++ {
AsyncQueue <- i
}
}
在消费时取出即可
func Customer(n int) {
wg.Add(1)
go func() {
var count int
for {
fmt.Println("get async item")
if count >= n {
wg.Done()
os.Exit(1)
}
count += 1
newOne := <-AsyncQueue
fmt.Println("Async Got:", newOne)
}
}()
wg.Wait()
}
运行输出
get async item
Async Got: 0
get async item
Async Got: 1
get async item
Async Got: 2
get async item
Async Got: 3
get async item
Async Got: 4
get async item
Async Got: 5
get async item
Async Got: 6
get async item
Async Got: 7
get async item
Async Got: 8
get async item
Async Got: 9
4 异步存入 和 异步取出
使用异步库的队列，存取先后顺序并不重要。 异步取 异步存
from asyncio import Queue
q = Queue()
loop.create_task(aconsumer(q))
loop.run_until_complete(aproducer(q, 10))
实际的输出
python async_third.py
Async Got: 0
Async Got: 1
Async Got: 2
Async Got: 3
Async Got: 4
Async Got: 5
Async Got: 6
Async Got: 7
Async Got: 8
Async Got: 9
5 异步存取 go的简单例子
go 的异步存入使用 内置的匿名函数即可
func PutsIn(n int) {
go func() {
for i := 0; i < n; i++ {
AsyncQueue <- i
}
}()
}
消费者保持不变
func Customer(n int) {
wg.Add(1)
go func() {
var count int
for {
fmt.Println("get async item")
if count >= n {
wg.Done()
os.Exit(1)
}
count += 1
newOne := <-AsyncQueue
fmt.Println("Async Got:", newOne)
}
}()
wg.Wait()
}
运行查看输出
go run main.go
get async item
Async Got: 0
get async item
Async Got: 1
get async item
Async Got: 2
get async item
Async Got: 3
get async item
Async Got: 4
get async item
Async Got: 5
get async item
Async Got: 6
get async item
Async Got: 7
get async item
Async Got: 8
get async item
Async Got: 9
6 小结
协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方在切回来的时候，恢复先前保存的寄存器上下文和栈。
因此，协程能保留上一次调用时的状态 也就是说：
进入上一次离开时所处逻辑流的位置。
线程和进程的操作是由程序触发系统接口，最后执行者是系统
协程的操作执行子则是用户自身程序，goroutine也是协程
goroutine 是Golang语言中最经典的设计，也是其魅力所在，goroutine本质是协程 是实现并行计算的核心。
goroutine 使用方式非常简单，只需要使用go关键字即可启动一个协程并且它是处于异步方式运行的，你不需要等它运行完成以后再执行以后的代码。
通过go 关键字启动一个协程来运行函数。
go func() {}()
groutine能拥有强大的并发实现是通过GPM调度模型实现。
使用go的特性与python的经典一般用法进行比较似乎不太公平，这里只做简单对比，了解其优点.
完整代码：
https://github.com/hahamx/examples/blob/main/alg_practice/1_pys_async/asyncio_cmp.py
