Photo by Jefferson Santos on Unsplash
并发&并行
并发程序含有多个逻辑上的独立执行块，他们可以独立的并行执行，也可以串行执行。 并行程序解决问题的速度比串行程序快的多，因为其可以同时执行整个任务的多个部分。并行程序可能有多个独立执行块，也可能只有一个。
引用Rob Pike的经典描述就是： 并发是同一时间应对多件事情的能力； 并行是同一时间动手做多件事情的能力。
常见的并发模型有：
线程与锁
函数式编程
actor模型和通信顺序是进行（Communicating Sequential Processes, CSP）
数据级并行
lambda 架构
分离标识与状态模型
这篇主要介绍线程与锁模型
线程与锁模型
线程与锁模型是对底层硬件运行过程的形式化，非常简单直接，几乎所有的编程语言都对其提供了支持，且不对其使用方法加以限制（易出错）。
这篇文章主要使用python语言来演示线程与锁模型。文章结构来自《七周七并发模型》
互斥和内存模型
创建线程
from threading import Thread
def hello_world():
print("Hello from new thread")
def main():
my_thread = Thread(target=hello_world)
my_thread.start()
print("Hello from main thread")
my_thread.join()
main()
这段代码创建并启动了一个Thread实例，首先从start() 开始，my_thread.start() main()函数的余下部分一起并发执行。最后调用join()来等待my_thread线程结束。
运行这段代码输出结果有几种：
Hello from new thread
Hello from main thread
或者
Hello from main thread
Hello from new thread
或者
Hello from new threadHello from main thread
究竟哪个结果取决于哪个线程先执行print()。多线程编程很难的原因之一就是运行结果可能依赖于时序，多次运行结果并不稳定。
第一把锁
from threading import Thread, Lock
class Counter(object):
def __init__(self, count=0):
self.count = count
def increment(self):
self.count += 1
def get_count(self):
print("Count: %s" % self.count)
return self.count
def test_count():
counter = Counter()
class CounterThread(Thread):
def run(self):
for i in range(10000):
counter.increment()
t1 = CounterThread()
t2 = CounterThread()
t1.start()
t2.start()
t1.join()
t2.join()
counter.get_count()
test_count()
这段代码创建一个简单的类Counter 和两个线程，每个线程都调用counter.increment() 10000次。
多次运行这段代码会得到不同的值，原因是两个线程在使用 counter.count 时发生了竞态条件（代码行为取决于各操作的时序）。
一个可能的操作是：
线程t1 获取count的值时，线程t2也同时获取到了count 的值（假设是100），
这时t1 count + 1， 此时count 为101，回写count 值，然后t2 执行了相同的操作 count+1，因为t2 取到的值也是100 此时 count 仍是101，回写后count 依然是101，但是 +1 操作执行了两次。
竞态条件的解决方法是对 count 进行同步（synchronize）访问。一种操作是使用 内置锁(也称互斥锁（mutex）、管程（monitor）或临界区（critical p）)来同步对increment() 的调用。
线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。互斥锁为资源引入一个状态：锁定/非锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改； 直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“同步阻塞”。 直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。
python 锁的使用流程如下：
#创建锁
mutex = threading.Lock()
#锁定
mutex.acquire([timeout])
#释放
mutex.release()
推荐使用上下文管理器来操作锁，
with lock:
do someting
# 相当于
lock.acquire()
try:
# do something...
finally:
lock.release()
acquire(blocking=True, timeout=-1) 可以阻塞或非阻塞地获得锁。 当调用时参数 blocking 设置为 True （缺省值），阻塞直到锁被释放，然后将锁锁定并返回 True 。 在参数 blocking 被设置为 False 的情况下调用，将不会发生阻塞。如果调用时 blocking 设为 True 会阻塞，并立即返回 False ；否则，将锁锁定并返回 True。 当浮点型 timeout 参数被设置为正值调用时，只要无法获得锁，将最多阻塞 timeout 设定的秒数。timeout 参数被设置为 -1 时将无限等待。当 blocking 为 false 时，timeout 指定的值将被忽略。 如果成功获得锁，则返回 True，否则返回 False (例如发生 超时 的时候)。 timeout 参数需要
python3.2+
from threading import Thread, Lock
mutex = Lock()
class SynchronizeCounter(object):
def __init__(self, count=0):
self.count = count
def increment(self):
# if mutex.acquire(1): # 获取锁
# self.count += 1
# mutex.release() # 释放锁
# 等同于上述代码
with mutex:
self.count += 1
def get_count(self):
print("Count: %s" % self.count)
return self.count
def test_synchronize_count():
counter = SynchronizeCounter()
class CounterThread(Thread):
def run(self):
for i in range(100000):
counter.increment()
t1 = CounterThread()
t2 = CounterThread()
t1.start()
t2.start()
t1.join()
t2.join()
counter.get_count()
if __name__ == "__main__":
for i in range(100):
test_synchronize_count()
这段代码还有一个隐藏的bug，那就是 get_count()，这里get_count() 是在join()之后调用的，因此是线程安全的，但是如果在其它地方调用了 get_count() 函数。 由于在 get_count() 中没有进行线程同步，调用时可能会获取到一个失效的值。
诡异的内存
对于JAVA等竞态编译语言，
编译器的静态优化可能会打乱代码的执行顺序
JVM 的动态优化也会打乱代码的执行顺序
硬件可以通过乱序执行来优化性能
更糟糕的是，有时一个线程产生的修改可能会对另一个线程不可见。
从直觉上来说，编译器、JVM、硬件都不应插手修改原本的代码逻辑。但是近几年的运行效率提升，尤其是共享内存交媾的运行效率提升，都仰仗于此类代码优化。 具体的副作用，Java 内存模型有明确说明。 Java 内存模型定义了何时一个线程对内存的修改对另一个线程可见。
基本原则是：如果读线程和写线程不进行同步，就不能保证可见性。
多把锁
一个重点： 两个线程都需要进行同步。只在其中一个线程进行同步是不够的。
可如果所有的方法都同步，大多数线程可能都会被阻塞，失去了并发的意义，并且可能会出现死锁。
哲学家进餐问题
哲学家就餐问题：假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉。因为用一只餐叉很难吃到意大利面，所以假设哲学家必须用两只餐叉吃东西。他们只能使用自己左右手边的那两只餐叉。
哲学家从来不交谈，这就很危险，可能产生死锁，每个哲学家都拿着左手的餐叉，永远都在等右边的餐叉（或者相反）。 即使没有死锁，也有可能发生资源耗尽。例如，假设规定当哲学家等待另一只餐叉超过五分钟后就放下自己手里的那一只餐叉，并且再等五分钟后进行下一次尝试。这个策略消除了死锁（系统总会进入到下一个状态），但仍然有可能发生“活锁”。如果五位哲学家在完全相同的时刻进入餐厅，并同时拿起左边的餐叉，那么这些哲学家就会等待五分钟，同时放下手中的餐叉，再等五分钟，又同时拿起这些餐叉。
下面是哲学家进餐问题的一个实现：
import threading
import random
import time
class Philosopher(threading.Thread):
running = True
def __init__(self, xname, forkOnLeft, forkOnRight):
threading.Thread.__init__(self)
self.name = xname
self.forkOnLeft = forkOnLeft
self.forkOnRight = forkOnRight
def run(self):
while self.running:
# Philosopher is thinking (but really is sleeping).
time.sleep(random.uniform(1, 3))
print("%s is hungry." % self.name)
self.dine()
def dine(self):
fork1, fork2 = self.forkOnLeft, self.forkOnRight
while self.running:
fork1.acquire(True) # 阻塞式获取left 锁
# locked = fork2.acquire(True) # 阻塞式 获取right 锁 容易产生死锁
locked = fork2.acquire(False) # 非阻塞式 获取right 锁
if locked:
break # 如果被锁定，释放 left 退出等待
fork1.release()
print("%s swaps forks" % self.name)
fork1, fork2 = fork2, fork1
else:
return
self.dining()
fork2.release()
fork1.release()
def dining(self):
print("%s starts eating " % self.name)
time.sleep(random.uniform(1, 5))
print("%s finishes eating and leaves to think." % self.name)
def DiningPhilosophers():
forks = [threading.Lock() for n in range(5)]
philosopherNames = ("Aristotle", "Kant", "Buddha", "Marx", "Russel")
philosophers = [
Philosopher(philosopherNames[i], forks[i % 5], forks[(i + 1) % 5])
for i in range(5)
]
Philosopher.running = True
for p in philosophers:
p.start()
for p in philosophers:
p.join()
time.sleep(100)
Philosopher.running = False
print("Now we're finishing.")
DiningPhilosophers()
外星方法的危害
规模较大的程序常用监听器模式来解耦模块，这里我们构造一个类从一个URL进行下载，Listeners 监听下载进度。
import requests
import threading
class Listeners(object):
def __init__(self, count=0):
self.count = count
self.done_count = 0.0
self.listeners = []
def append(self, listener):
self.listeners.append(listener)
def remove(self, listener):
self.listeners.remove(listener)
def on_progress(self, n):
# 一些我们不知道的实现
# do someting
# self.done_count += 1
# print("Process: %f" % (self.done_count / self.count))
pass
listeners = Listeners(5)
class Downloader(threading.Thread):
def __init__(
self, group=None, target=None, name=None, args=(), kwargs=None, daemon=None
):
threading.Thread.__init__(
self, group=group, target=target, name=name, daemon=daemon
)
self.url = kwargs.get("url")
def download(self):
resp = requests.get(self.url)
def add_listener(self, listener):
listeners.append(listener)
def remove_listener(self, listener):
listeners.delete(listener)
def update_progress(self, n):
for listener in listeners:
listner.on_progress(n)
def run(self):
self.download()
print(self.url)
listeners.on_progress(1)
def test():
urls = [
"https://www.baidu.com",
"https://www.google.com",
"https://www.bing.com",
"https://www.zaih.com",
"https://www.github.com",
]
ts = [Downloader(kwargs=dict(url=url)) for url in urls]
print(ts)
[t.start() for t in ts]
[t.join() for t in ts]
if __name__ == "__main__":
test()
这段代码中，add_listener， remove_listener 和 update_progress 都是同步方法，但 update_progress 调用了一个我们不知道如何实现的方法。如果这个方法中，获取了一把锁，程序在执行的过程中就可能发生死锁。所以，我们要尽量避免使用这种方法。还有一种方法是在遍历之前对 listeners 进行保护性复制，再针对这份副本进行遍历。（现在调用外星方法不再需要加锁）
下一篇会介绍锁的其它操作，地址为：《并发模型：线程与锁（2）》 https://mp.weixin.qq.com/s/3AImdyFFVcfpLuUbG5kV0g
参考链接
Let’s Synchronize Threads in Python
哲学家进餐问题
References
[1] 哲学家进餐问题: https://zh.wikipedia.org/wiki/%E5%93%B2%E5%AD%A6%E5%AE%B6%E5%B0%B1%E9%A4%90%E9%97%AE%E9%A2%98
[2] Let’s Synchronize Threads in Python: https://hackernoon.com/synchronization-primitives-in-python-564f89fee732?gi=ce162d119247
[3] 并发模型：线程与锁（2） https://mp.weixin.qq.com/s/3AImdyFFVcfpLuUbG5kV0g
最后，感谢女朋友支持和包容，比❤️
也可以在公号输入以下关键字获取历史文章：公号&小程序 | 设计模式 | 并发&协程
110
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
