一、进程理论
1）进程介绍
、什么是进程
一个正在进行的过程，或者说是一个程序的运行过程
其实进程是对正在运行的程序的一种抽象/概括的说法 进程的概念起源操作系统，进程是操作最核心的概念之一
操作系统其他所有的概念都是围绕进程展开的 、多道路技术
产生背景：针对单核，实现并发
ps：
现在的主机一般是多核，那么每个核都会利用多道技术
有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
cpu中的任意一个，具体由操作系统调度算法决定。 .空间上的复用：如内存中同时有多道程序
.时间上的复用：复用一个cpu的时间片
强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
才能保证下次切换回来时，能基于上次切走的位置继续运行 、并发vs并行
并发（单核就可以实现并发）
多个任务看起来是同时运行的就是并发
并发的实现=切换+保存状态 并行（只有多核才能实现并行）
真正意义上的同时运行
2）进程状态
tail -f access.log |grep ''
执行程序tail，开启一个子进程，执行程序grep，开启另外一个子进程，两个进程之间基于管道'|'通讯，将tail的结果作为grep的输入。
进程grep在等待输入（即I/O）时的状态称为阻塞，此时grep命令都无法运行
其实在两种情况下会导致一个进程在逻辑上不能运行，
. 进程挂起是自身原因，遇到I/O阻塞，便要让出CPU让其他进程去执行，这样保证CPU一直在工作
. 与进程无关，是操作系统层面，可能会因为一个进程占用时间过多，或者优先级等原因，而调用其他的进程去使用CPU。
因而一个进程由三种状态
3）进程并发的实现
程并发的实现在于，硬件中断一个正在运行的进程，把此时进程运行的所有状态保存下来，为此，操作系统维护一张表格，即进程表（process table），每个进程占用一个进程表项（这些表项也称为进程控制块）
该表存放了进程状态的重要信息：程序计数器、堆栈指针、内存分配状况、所有打开文件的状态、帐号和调度信息，以及其他在进程由运行态转为就绪态或阻塞态时，必须保存的信息，从而保证该进程在再次启动时，就像从未被中断过一样。
Python并发编程理论原文链接：http://www.cnblogs.com/linhaifeng/articles/7430066.html
二、进程
1）开启子进程
from multiprocessing import Process
import time def task(x):
print('%s is running' %x)
time.sleep()
print("%s is done" %x) if __name__ == '__main__':
# Process(target=task,kwargs={'x':'任务1'}) # 生成一个进程对象
p=Process(target=task,args=('任务1',)) # 元组必须加逗号，否则是字符串类型
p.start() # 只是给操作系统发送一个开启子进程的信号
print('主')
2）查看进程号（进程ID），pid及ppid
from multiprocessing import Process
import time
import os def task():
print('子进程的pid:%s，父进程的pid ppid:%s' %(os.getpid(),os.getppid()))
time.sleep() if __name__ == '__main__':
p=Process(target=task,)
p.start()
print('主:',os.getpid(),os.getppid())
tasklist 查看ID
tasklist | findstr 11244 过滤ID
3）使用自定义类方法来创建子进程
from multiprocessing import Process
import time class MyProcess(Process):
def __init__(self,name):
super().__init__()
self.name=name def run(self): # 函数名一定得叫run
print('%s is ruuning' %self.name)
time.sleep()
print('%s is done' %self.name) def func(self):
print('new func') if __name__ == '__main__':
p=MyProcess('egon')
p.start() # 调用类里面的 run 方法，即run 方法乃 子进程
print('主') p.func()
4）join 方法。必先执行完子进程，才能执行主进程
from multiprocessing import Process
import time def task(x):
print('%s is ruuning' %x)
time.sleep()
print('%s is done' %x) if __name__ == '__main__':
p=Process(target=task,args=('子进程',))
p.start()
# time.sleep()
p.join() #主进程在等，一直等到子进程p运行完毕后再执行下一行代码
print('主')
多个子进程，重用执行的时间，用时 3.6552090644836426秒。会与后面的线程对比
from multiprocessing import Process
import time,os def task(n):
print('%s is ruuning' %os.getpid())
time.sleep(n) if __name__ == '__main__':
p1=Process(target=task,args=(,))
p2=Process(target=task,args=(,))
p3=Process(target=task,args=(,))
start_time=time.time()
p1.start()
p2.start()
p3.start() p1.join()
p2.join()
p3.join()
stop_time=time.time()
print('主',(stop_time - start_time)) # 主 3.6552090644836426
循环添加进程，并循环执行
from multiprocessing import Process
import time,os def task(n):
print('%s is ruuning' %os.getpid())
time.sleep(n) if __name__ == '__main__':
p_l=[]
start_time=time.time()
for i in range(,):
p=Process(target=task,args=(i,))
p_l.append(p)
p.start() for p in p_l:
p.join() stop_time=time.time()
print('主',(stop_time - start_time))
5）进程的其他方法，属性
p.name,p.pid # 打印子进程的名字
p.pid # 子进程的pid
p.terminate() # 强行终止子进程
print(p.is_alive()) # 查看子进程是否还活着
from multiprocessing import Process
import time,os def task(n):
print('%s is ruuning' %os.getpid())
time.sleep(n) if __name__ == '__main__':
p=Process(target=task,args=(,),name='子进程1')
p.start()
# print(p.name,p.pid) # 打印子进程的名字，查看子进程的pid
# p.terminate() # 强行终止子进程
# time.sleep()
p.join()
print(p.is_alive()) # 查看进程是否还活着
print('主')
示例
6）进程之间内存隔离
from multiprocessing import Process
import time,os x=
def task():
global x
x= if __name__ == '__main__':
p=Process(target=task)
p.start() # p.join()
print('主',x)
7）多进程实现socket并发操作
import socket
from multiprocessing import Process def talk(conn):
while True:
try:
data = conn.recv()
if not data: break
print('客户端数据：%s' % data)
conn.send(data.upper())
except ConnectionResetError:
break conn.close() def server(ip,port):
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #流式协议指的就是tcp协议
phone.bind((ip,port)) #端口范围0-
phone.listen() #限制的是请求数，而非链接数 print('服务的启动......')
while True: # 连接循环
conn,client_addr=phone.accept()
print(client_addr) # 通信循环
# talk(conn)
p=Process(target=talk,args=(conn,))
p.start() phone.close() if __name__ == '__main__':
server('127.0.0.1',)
服务端
import socket phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',)) while True:
msg=input('>>>: ').strip()
if not msg:continue
phone.send(msg.encode('utf-8')) data=phone.recv()
print(data.decode('utf-8')) phone.close()
客户端
这种方法不科学，设置过多的进程，会大量消耗资源。并且，收到的并发数量大于进程数量，服务端会崩溃掉。
原文链接：http://www.cnblogs.com/linhaifeng/articles/7428874.html
三、线程
1）线程介绍
什么线程
线程就是一条流水线的工作过程，一个进程内至少有一个线程
进程只是一个资源单位
而进程内的线程才执行单位 为什么要多线程（进程vs线程）
、同一进程下的多个线程共享该进程内的数据
、线程的创建开销要远远小于进程的 如何用线程
、from threading import Thread
、t=Thread(target=def,args=(xxx,))
2）开启线程的2种方式
第一种，函数方式
from threading import Thread
import time,random def piao(name):
print('%s is piaoing' %name)
time.sleep(random.randint(,))
print('%s is piao end' % name) if __name__ == '__main__':
t=Thread(target=piao,args=('user',))
t.start()
print('主')
第二种，类方式
from threading import Thread
import time,random class Mythread(Thread):
def run(self):
print('%s is piaoing' %self.name)
time.sleep(random.randint(,))
print('%s is piao end' % self.name) if __name__ == '__main__':
t=Mythread()
t.start()
print('主')
3）线程之间数据共享
from threading import Thread x=
def task():
global x
x= if __name__ == '__main__':
t=Thread(target=task)
t.start()
t.join()
print('主',x)
4）线程的其他属性方法，如定义线程名，线程的存活状态
from threading import Thread def task(name):
print('%s is ruuning' %name) if __name__ == '__main__':
t=Thread(target=task,args=('egon',),name='线程1')
t.start()
print(t.is_alive()) t.setName('线程')
print(t.getName())
# print('主')
在线程里查看自己的线程名的方法
from threading import Thread,current_thread def task():
print('%s is ruuning' %current_thread().getName()) if __name__ == '__main__':
t=Thread(target=task)
t.setName('线程')
t.start()
print('主')
5）同一个进程下的线程的pid一样，以及执行的效率比进程快近100倍。耗时：3.0161726474761963
from threading import Thread,current_thread
import os,time def task(n):
print('%s is ruuning,pid:%s' %(current_thread().getName(),os.getpid()))
time.sleep(n) if __name__ == '__main__':
t1=Thread(target=task,args=(,))
t2=Thread(target=task,args=(,))
t3=Thread(target=task,args=(,)) start=time.time()
t1.start()
t2.start()
t3.start() t1.join()
t2.join()
t3.join()
print('主',os.getpid())
print(time.time()-start)
原文链接http://www.cnblogs.com/linhaifeng/articles/7428877.html