内容转载自网络、非原创！此处仅仅收集整理一下方便学习！
```
python 并发和线程
并发和线程
基本概念 - 并行、并发
"并行、 parallel"
互不干扰的在同一时刻做多件事;
如、同一时刻、同时有多辆车在多条车道上跑、即同时发生的概念.
"并发、 concurrency"
同时做某些事、但是强调同一时段做多件事.
如、同一路口、发生了车辆要同时通过路面的事件.
"队列、 缓冲区"
类似排队、是一种天然解决并发的办法.排队区域就是缓冲区.
```
```
解决并发:
【 "食堂打饭模型", 中午12点,大家都涌向食堂,就是并发.人很多就是高并发.】
1、队列, 缓冲区:
队列: 即排队.
缓冲区: 排成的队列.
优先队列: 如果有男生队伍和女生队伍,女生队伍优先打饭,就是优先队列.
2、争抢:
锁机制: 争抢打饭,有人抢到,该窗口在某一时刻就只能为这个人服务,锁定窗口,即锁机制.
争抢也是一种高并发解决方案,但是有可能有人很长时间抢不到,所以不推荐.
3、预处理:
统计大家爱吃的菜品,最爱吃的80%热门菜提前做好,20%冷门菜现做,这样即使有人锁定窗口,也能很快释放.
这是一种提前加载用户需要的数据的思路,预处理思想,缓存常用.
4、并行:
开多个打饭窗口,同时提供服务.
IT日常可以通过购买更多服务器,或多开线程,进程实现并行处理,解决并发问题.
这是一种水平扩展的思路.
注: 如果线程在单CPU上处理,就不是并行了.
5、提速:
通过提高单个窗口的打饭速度,也是解决并发的方式.
IT方面提高单个CPU性能,或单个服务器安装更多的CPU.
这是一种垂直扩展的思想.
6、消息中间件:
如上地地铁站的九曲回肠的走廊,缓冲人流.
常见消息中间件: RabbitMQ, ActiveMQ(Apache), RocketMQ(阿里Apache), kafka(Apache)等.
```
```
进程和线程
a) 在实现了线程的操作系统中,线程是操作系统能够运算调度的最小单位.
b) 线程被包含在进程中,是进程的实际运作单位.
c) 一个程序的执行实例就是一个进程.
进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础.
进程和程序的关系: 进程是线程的容器.
Linux进程有父进程和子进程之分,windows的进程是平等关系.
线程有时称为轻量级进程,一个标准的线程由线程ID,当前指令指针,寄存器集合和堆栈组成.
当运行一个程序时,OS会创建一个进程。它会使用系统资源（CPU、内存和磁盘空间）和OS内核中的数据结构（文件、网络连接、用量统计等）。
进程之间是互相隔离的，即一个进程既无法访问其他进程的内容，也无法操作其他进程。
操作系统会跟踪所有正在运行的进程，给每个进程一小段运行时间，然后切换到其他进程，这样既可以做到公平又可以响应用户操作。
可以在图形界面中查看进程状态，在在Windows上可以使用任务管理器。也可以自己编写程序来获取进程信息。
```
```
# 获取正在运行的python解释器的进程号和当前工作目录,及用户ID、用户组ID
import os
os.getpid()
os.getuid()
os.getcwd()
os.getgid()
```
```
对线程、线程的理解:
进程是独立的王国,进程间不能随便共享数据.
线程是省份,同一进程内的线程可以共享进程的资源,每一个线程有自己独立的堆栈.
线程的状态:
就绪(Ready): 线程一旦运行,就在等待被调度.
运行(Running): 线程正在运行.
阻塞(Blocked): 线程等待外部事件发生而无法运行,如I/O操作.
终止(Terminated): 线程完成或退出,或被取消.
```
```
python中的进程和线程: 进程会启动一个解释器进程,线程共享一个解释器进程.
python的线程开发
python线程开发使用标准库threading.
thread类
def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None)
target: 线程调用的对象,就是目标函数.
name: 为线程起个名字.
args: 为目标函数传递实参, 元组.
kwargs: 为目标函数关键字传参, 字典.
```
```
import threading
def worker():
print("I'm working")
print("Finished")
t = threading.Thread(target=worker, name='worker') # 线程对象.
t.start()
```
```
通过threading.Thread创建一个线程对象,target是目标函数,name可以指定名称.
但是线程没有启动,需要调用start方法.
线程会执行函数,是因为线程中就是执行代码的,而最简单的封装就是函数,所以还是函数调用.
函数执行完,线程也会随之退出.
如果不让线程退出，或者让线程一直工作: 函数内部使用while循环.
```
```
import threading
import time
def worker():
while True:
time.sleep(1)
print("I'm 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()
# return
time.sleep(1)
print("I'm working")
count += 1
t = threading.Thread(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.Thread(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("I'm working")
t = threading.Thread(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(): 启动线程。每一个线程必须且只能执行该方法一次。
run(): 运行线程函数。
为了演示,派生一个Thread子类
```
```
# 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)
```
```
t.start()
t.run()
start()方法会调用run()方法，而run()方法可以运行函数。
```