并发和并行
你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。
你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。
你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。
并发的关键是你有处理多个任务的能力，不一定要同时。
并行的关键是你有同时处理多个任务的能力。
所以我认为它们最关键的点就是：是否是『同时』。
如果某个系统支持两个或者多个动作（Action）同时存在，那么这个系统就是一个并发系统。如果某个系统支持两个或者多个动作同时执行，那么这个系统就是一个并行系统。并发系统与并行系统这两个定义之间的关键差异在于“存在”这个词。在并发程序中可以同时拥有两个或者多个线程。这意味着，如果程序在单核处理器上运行，那么这两个线程将交替地换入或者换出内存。这些线程是同时“存在”的——每个线程都处于执行过程中的某个状态。如果程序能够并行执行，那么就一定是运行在多核处理器上。此时，程序中的每个线程都将分配到一个独立的处理器核上，因此可以同时运行。我相信你已经能够得出结论——“并行”概念是“并发”概念的一个子集。也就是说，你可以编写一个拥有多个线程或者进程的并发程序，但如果没有多核处理器来执行这个程序，那么就不能以并行方式来运行代码。因此，凡是在求解单个问题时涉及多个执行流程的编程模式或者执行行为，都属于并发编程的范畴。
解决并发的方式
- 使用队列，增加缓存区、优先队列；
- 采用锁机制，但可能引起单独线程长时间不执行，不推荐采纳；
- 预处理，提前加载用户需要的数据，缓存常用；
- 并行，购买更多服务器，或多开线程，进程实现并行处理，解决并发问题；
- 提速，提高单个CPU性能或单个服务器安装更多CPU；
- 消息中间件，RabbitMQ, ActiveMQ(Apache), RocketMQ(阿里Apache), kafka(Apache)；
线程开发
python线程开发使用标准库threading
thread类
def __init__(self, group=None, target=None, name=None, args=(),kwargs=None, *, daemon=None)
target：线程调用的对象，就是目标函数；
name：为线程起个名字；
args：为目标函数传递实参，元组；
kwargs：为目标函数关键字传参，字典；
# 最简单的线程程序
def worker():
print("working")
print("finished")
t = threading.Thread(target=worker, name='worker') # 线程对象
t.start()
线程会执行函数，是因为线程中就是执行代码的，而最简单的封装就是函数，所以还是函数调用。函数执行完，线程也会随之退出。如果不让线程退出，或者让线程一致工作，函数内部使用while循环。
import threading
import time
def worker():
while True:
time.sleep(1)
print("work")
print("finished")
t = threading.Thread(target = worker, name='worker') # 线程对象
t.start()
线程退出
python没有提供线程退出的方法，在下面情况时会退出：
- 线程函数内语句执行完毕；
- 线程函数中抛出未处理的异常；
import threading
import time
def worker():
count = 0
while True:
if (count > 5):
raise RuntimeError()
time.sleep(1)
print("working")
count += 1
t = threading.Tread(target=worker, name = 'worker') # 线程对象
t.start()
print("==END==")
python的线程没有优先级，没有线程组的概念，也不能被销毁、停止、挂起，自然也没有恢复、中断。
线程传参
import threading
import time
def add(x, y):
print('{} + {} = {}'.format(x, y, x + y, threading.current_thread()))
thread1 = threading.Thread(target=add, name='add', args=(4, 5)) # 线程对象
thread1.start()
time.sleep(2)
thread2 = threading.Thread(target = add, name='add', args = (5, ), kwargs={'y': 4}) ＃线程对象
thread2.start()
time.sleep(2)
thread3 = threading.Threading(target=add, name='add', kwargs={'x' : 4, 'y':5}) # 线程对象
thread3.start()
线程传参与函数传参没什么区别，本质上就是传参。
threading的属性和方法
current_thread() 返回当前线程对象；
main_thread() 返回主线程对象；
active_count() 当前处于alive状态的线程个数；
enumerate() 返回所有活着的线程列表，不包括已经终止的线程和未开始的线程；
get_ident() 返回当前线程ID，非0整数；
active_count、enumerate方法返回的值还包括主线程。
import threading
import time
def showthreadinfo():
print('currentthread = {}'.format(threading.current_thread()))
print('main thread = {}'.format(threading.main_thread()),'"主线程对象"')
print('active count = {}'.format(threading.active_count()),'"alive"')
def worker():
count = 1
showthreadinfo()
while True:
if (count > 5):
break
time.sleep(1)
count += 1
print("work")
t = threading.Tread(target = worker, name='worker') # 线程对象
showthreadinfo()
t.start()
print('==END==')
thread实例的属性和方法
name : 只是一个名称标识，可以重名，getName()、setName()来获取、设置这个名词。
ident：线程ID，它是非0整数。线程启动后才会有ID，否则为None。线程退出，此ID依旧可以访问。此ID可以重复使用。
is_alive()：返回线程是否或者。
注：线程的name是一个名称，可以重复，ID必须唯一，但可以在线程退出后再利用。
import threading
import time
def worker():
count = 0
while True:
if (count > 5):
break
time.sleep(1)
count += 1
print(threading.current_thread().name,'~~~~~')
t = threading.Thread(name='worker', target = worker)
print(t.ident)
t.start()
while True:
time.sleep(1)
if t.is_alive():
print('{} {} alive'.format(t.name, t.ident))
else:
print('{} {} dead'.format(t.name, t.ident))
t.start()
start 启动线程，每一个线程必须智能执行一次该方法。
import threading
import time
def worker():
count = 0
while True:
if (count >= 5):
break
time.sleep(1)
count += 1
print('worker running')
class MyThread(threading.Thread):
def start(self):
print('start~~~~~~~~~~~~~')
super().start()
def run(self):
print('run~~~~~~~~~~~~~~~~~')
super().run()
t = MyThread(name='worker', target=worker)
t.start()
run 运行线程函数
import threading
import time
def worker():
count = 0
while True:
if (count > 5):
break
time.sleep(1)
count += 1
print('worker running')
class MyThread(threading.Thread):
def start(self):
print('start~~~~~~~~~~~~~~~')
super().start()
def run(self):
print('run~~~~~~~~~~~~~~~~~')
super().run()
t = MyThread(name='worker', target=worker)
start方法会调用run方法，而run方法可以运行函数。这两个方法看似功能重复，但不能只留其一。
import threading
import time
def worker():
count = 0
while True:
if (count > 5):
break
time.sleep(1)
count += 1
print("worker running")
print(threading.current_thread().name)
class MyThread(threading.Thread):
def start(self):
print('start~~~~~~~~~~~~~')
super().start()
def run(self):
print('run~~~~~~~~~~~~~~~')
super().run()
t = MyThread(name='worker', target=worker)
# t.start()
t.run()分别执行start或者run方法。使用start方法启动线程，启动了一个新的线程，名字叫做worker running.但是使用run方法启动的线程，并没有启动新的线程，只是在主线程中调用了一个普通函数而已。
因此，启动线程要使用start方法，才能启动多个线程。
多线程
多个线程实现一种并发。
import threading
import time
def worker():
count = 0
while True:
if (count > 5):
break
time.sleep(2)
count += 1
print('work')
print(threading.current_thread().name, threading.current_thread().ident)
class MyThead(threading.Thread):
def start(self):
print('start~~~~')
super().start()
def run(self):
print('run~~~~')
super().run() # 查看父类在做什么
t1 = MyThread(name='worker1', target = worker)
t2 = MyThread(name='worker2', target = worker)
t1.start()
t2.start()
可以看到worker1和worker2交替执行。
换成run方法试试：
import threading
import time
def worker():
count = 0
while True:
if (count > 5):
break
time.sleep(1)
count += 1
print('worker running')
print(threading.current_thread().name, threading.current_thead().ident)
class MyThead(threading.Thread):
def start(self):
print('start~~~')
super().start()
def run(self):
print('run~~~~')
super().run()
t1 = MyThread(name='worker1',target=worker)
t2 = MyThread(name='worker2', target=worker)
# t1.start()
# t2.start()
t1.run()
t2.run()
没有开新的线程，这就是普通函数调用，所以执行完t1.run()，然后执行t2.run()，这里就不是多线程。
当使用start方法启动线程后，进程内有多个活动的线程并行的工作，就是多线程。
一个进程中至少有一个线程，并作为程序的入口，这个线程就是主线程。一个进程至少有一个主线程。
其他线程称为工作线程。
线程安全
import threading
def worker():
for x in range(5):
print("{} is running".format(threading.current_thread().name))
for x in range(1, 5):
name = 'worker{}'.format(x)
t = threading.Thread(name=name, target=worker)
t.start()
可以看到运行结果中，本应该是一行行打印，但很多字符串打印在了一起，这说明print函数被打断了，被线程切换打断了。
print函数分两步，第一步打印字符串，第二部换行，就在这之间，发生了线程的切换。
说明print函数不是线程安全函数。
线程安全：线程执行一段代码，不会产生不确定的结果，那这段代码就是线程安全的。
- 不让print打印换行
import threading
def worker():
for x in range(100):
print('{} is running\n'.format(threading.current_thread().name), end='')
for x in range(1, 5):
name = 'worker{}'.format(x)
t = threading.Thread(name=name,target=worker)
t.start()
字符串是不可变类型，他可以作为一个整体不可分割输出。end=''的作用就是不让print换行输出。
- 使用logging
标准库里面的logging模块、日志处理模块、线程安全、生成环境代码都使用logging.
import threading
import logging
def worker():
for x in range(100):
logging.warning('{} is running'.format(threading.current_thread().name))
for x in range(1, 5):
name = 'work{}'.format(x)
t = threading.Thread(name=name, target=worker)
t.start()
daemon线程和non-daemon线程
注：这里的daemon不是linux中的守护进程。
进程靠线程执行代码，至少有一个主线程，其他线程是工作线程。
主线程是第一个启动的线程。
父线程：如果线程A中启动了一个线程B，A就是B的父线程。
子线程：B就是A的子线程。
python中构造线程的时候可以设置daemon属性，这个属性必须在start方法之前设置好。
源码Thread的init方法中：
if daemon is not None:
self._daemonic = daemon
else:
self._daemonic = current_thread().daemon
self._ident = None
线程daemon属性，如果设定就是用户的设置，否则就取当前线程的daemon值。
主线程是non-daemon，即daemon = False.
import time
import threading
def foo():
time.sleep(5)
for i in range(20):
print(i)
主线程是non-daemon线程。
t = threading.Thread(target = foo, daemon = False)
t.start()
print('Main Thread Exiting')
运行发现线程t依然执行，主线程已经执行完，但是一致等着线程t。
修改为t = threading.Threading(target = foo, daemon = True)，运行发现主线程执行完程序立即结束，根本没有等线程t。
import threading
import logging
logging.basicConfig(level=logging.INFO) # 警告级别
import time
def worker():
for x in range(10):
time.sleep(1)
msg = ("{} is running".format(threading.current_thread()0)
logging.info(msg)
t = threading.Thread(target=worker1, name="worker1-{}".format(x),daemon=False)
t.start()
# t.join()
def worker1():
for x in range(10):
time.sleep(0.3)
msg = ("{} is running".format(threading.current_thread()))
logging.info(msg)
t = threading.Thread(target=worker,name='worker-{}'.format(0),daemon=True)
t.start()
# t.join()
time.sleep(0.3)
print('ending')
print(threading.enumerate())
结论：
daemon = False运行发现子线程依然执行，i经执行完，但是主线程会一致等着子线程执行完。
daemon = True 运行发现主线程执行完程序立即结束了。
daemon属性：表示线程是否是daemon线程，这个值必须在start()之前设置，否则引发RuntimeError异常。
isDaemon()：是否是daemon线程。
setDaemon：设置为daemon线程，必须在start方法之前设置。
总结：
线程具有一个daemon属性，可以显示设置为True或False，也可以不设置则取默认值None。
如果不设置daemon，就取当前线程的daemon来设置它。子子线程继承子线程的daemon值，zuoy哦那个和设置None一样。
主线程是non-daemon线程，即daemon=False。
从主线程创建的所有线程不设置daemon属性，则默认都是daemon=False，也就是non-daemon线程。
python程序在没有活着的non-daemon线程运行时退出，也就是剩下的智能是daemon线程，主线程才能退出，否则只能等待。
import time
import threading
def bar():
time.sleep(10)
print('bar')
def foo():
for i in range(20):
print(i)
t = threading.Thread(target=bar,daemon=False)
t.start()
# 主线程是non-daemon线程
t = threading.Tread(target=foo, daemon=True)
t.start()
print('Main Threading Exiting')
上例中，没有输出bar这个字符串，如何修改才会打印出来bar?
import time
import threading
def bar():
time.sleep(1)
print('bar')
def foo():
for i in range(5):
print(i)
t = threading.Thread(target=bar, daemon=False)
t.start()
# 主线程是non-daemon线程.
t = threading.Thread(target=foo, daemon=True)
t.start()
time.sleep(1)
print('Main Threading Exiting')
再看一个例子，主线程合适结束daemon线程。
import time
import threading
def foo(n):
for i in range(n):
print(i)
time.sleep(1)
t1 = threading.Thread(target=foo, args = (10, ), daemon=True) # 调换10和20，看看效果。
t1.start()
t2 = threading.Thread(target=foo, args = (20, ), daemon=False)
t2.start()
time.sleep(2)
print('Main Threading Exiting')
上例说明如果有non-daemon线程的时候，主线程退出时，也不会杀掉所有daemon线程，直到所有non-daemon线程全部结束，如果还有daemon线程，主线程需要退出，会结束所有daemon线程，退出。
join方法
import time
import threading
def foo(n):
for i in range(n):
print(i)
time.sleep(1)
t1 = threading.Thread(target=foo, args=(10, ), daemon=False)
t1.start()
t1.join() # 设置join.
print('Main Thread Exiting')
使用了join方法后，daemon线程执行完了，主线程才退出。
join(timeout=None),是线程的标准方法之一。
一个线程中调用另一个线程的join方法，调用者将被阻塞，直到被调用线程终止。
一个线程可以被join多次。
timeout参数指定调用者等待多久，没有设置超时，就一直等待被调用线程结束。
调用谁的join方法，就是join谁，就要等谁。
网友评论