python中的多线程和多进程,python多进程操作数据库

　　本文为您带来了一些关于python的知识，包括多进程、进程创建、进程同步、进程池等等。下面就来看看吧，希望对你有帮助。

　　推荐：python视频教程

　　00-1010

一、什么是多进程？

　　进程：程序运行后，代码使用的资源称为进程，是操作系统分配资源的基本单位。您不仅可以通过线程完成多任务，还可以通过进程完成多任务。

　　00-1010工作时，任务数往往大于cpu核数，即有的任务正在执行，有的任务在等待cpu执行，从而导致不同的状态。

　　就绪态:运行状态已经变慢，正在等待cpu执行。执行态:中央处理器正在执行它的功能。等待态:等待某些条件得到满足，例如程序休眠。此时，等待状态

1. 进程

2. 进程的状态

　　语法格式:多重处理。进程(group=None，target=None，name=None，args=()，kwargs={}，*，daemon=None)

　　参数说明:

　　Group:指定过程组，在大多数情况下，不使用target。如果传递了对函数的引用，这个子流程可以在这里执行代码。name:给进程起一个名字，可以不用args。将kwargs作为元组传递。将命名参数multiprocessing.Process 对象具有如下方法和属性：传递给target指定的函数。

　　方法名称/属性描述了run()进程具体执行的方法。start () Promoter进程实例(创建子进程)join([timeout])如果可选参数timeout的默认值为None，则阻止调用join()方法的进程终止；如果timeout是正数，它最多阻塞超时秒数。name是当前进程的别名，默认为Process-N，N是当前进程从1递增的整数pid。当前进程is_alive()的pid(进程号)决定了该进程的子进程是否还活着。子进程的exitcode。守护进程的守护标志是一个布尔值。authkey进程的身份验证密钥。sentinel系统对象的数字句柄，它将在进程结束时就绪。Terminate()无论任务是否完成，立即终止子进程kill()与terminate()相同，但在Unix上使用SIGKILL信号。Close()关闭进程对象并释放与之相关的所有资源

二、进程的创建-multiprocessing

　　e"># -*- coding:utf-8 -*-from multiprocessing import Processimport timedef run_proc():

　　 """子进程要执行的代码"""

　　 while True:

　　 print("----2----")

　　 time.sleep(1)if __name__=='__main__':

　　 p = Process(target=run_proc)

　　 p.start()

　　 while True:

　　 print("----1----")

　　 time.sleep(1)运行结果：

说明：创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动

3. 进程pid

# -*- coding:utf-8 -*-from multiprocessing import Processimport osimport timedef run_proc():
　　 """子进程要执行的代码"""
　　 print('子进程运行中，pid=%d...' % os.getpid()) # os.getpid获取当前进程的进程号
　　 print('子进程将要结束...')if __name__ == '__main__':
　　 print('父进程pid: %d' % os.getpid()) # os.getpid获取当前进程的进程号
　　 p = Process(target=run_proc)
　　 p.start()

4. 给子进程指定的函数传递参数

# -*- coding:utf-8 -*-from multiprocessing import Processimport osfrom time import sleepdef run_proc(name, age, **kwargs):
　　 for i in range(10):
　　 print('子进程运行中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
　　 print(kwargs)
　　 sleep(0.2)if __name__=='__main__':
　　 p = Process(target=run_proc, args=('test',18), kwargs={"m":20})
　　 p.start()
　　 sleep(1) # 1秒中之后，立即结束子进程
　　 p.terminate()
　　 p.join()

5. 进程间不同享全局变量

# -*- coding:utf-8 -*-from multiprocessing import Processimport osimport time
　　nums = [11, 22]def work1():
　　 """子进程要执行的代码"""
　　 print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
　　 for i in range(3):
　　 nums.append(i)
　　 time.sleep(1)
　　 print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))def work2():
　　 """子进程要执行的代码"""
　　 print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))if __name__ == '__main__':
　　 p1 = Process(target=work1)
　　 p1.start()
　　 p1.join()
　　 p2 = Process(target=work2)
　　 p2.start()

in process1 pid=11349 ,nums=[11, 22]in process1 pid=11349 ,nums=[11, 22, 0]in process1 pid=11349 ,
　　nums=[11, 22, 0, 1]in process1 pid=11349 ,nums=[11, 22, 0, 1, 2]in process2 pid=11350 ,nums=[11, 22]

三、进程间同步-Queue

Process之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。

　　

1. Queue类语法说明

2. Queue的使用

#coding=utf-8from multiprocessing import Queue
　　q=Queue(3) #初始化一个Queue对象，最多可接收三条put消息q.put("消息1") q.put("消息2")print(q.full()) #Falseq.put("消息3")print(q.full()) #True#因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常try:
　　 q.put("消息4",True,2)except:
　　 print("消息列队已满，现有消息数量:%s"%q.qsize())try:
　　 q.put_nowait("消息4")except:
　　 print("消息列队已满，现有消息数量:%s"%q.qsize())#推荐的方式，先判断消息列队是否已满，再写入if not q.full():
　　 q.put_nowait("消息4")#读取消息时，先判断消息列队是否为空，再读取if not q.empty():
　　 for i in range(q.qsize()):
　　 print(q.get_nowait())

FalseTrue消息列队已满，现有消息数量:3消息列队已满，现有消息数量:3消息1消息2消息3

3. Queue实例

from multiprocessing import Process, Queueimport os, time, random# 写数据进程执行的代码:def write(q):
　　 for value in ['A', 'B', 'C']:
　　 print('Put %s to queue...' % value)
　　 q.put(value)
　　 time.sleep(random.random())# 读数据进程执行的代码:def read(q):
　　 while True:
　　 if not q.empty():
　　 value = q.get(True)
　　 print('Get %s from queue.' % value)
　　 time.sleep(random.random())
　　 else:
　　 breakif __name__=='__main__':
　　 # 父进程创建Queue，并传给各个子进程：
　　 q = Queue()
　　 pw = Process(target=write, args=(q,))
　　 pr = Process(target=read, args=(q,))
　　 # 启动子进程pw，写入:
　　 pw.start() 
　　 # 等待pw结束:
　　 pw.join()
　　 # 启动子进程pr，读取:
　　 pr.start()
　　 pr.join()
　　 # pr进程里是死循环，无法等待其结束，只能强行终止:
　　 print('')
　　 print('所有数据都写入并且读完')

四、进程间同步-Lock

锁是为了确保数据一致性。比如读写锁，每个进程给一个变量增加 1，但是如果在一个进程读取但还没有写入的时候，另外的进程也同时读取了，并写入该值，则最后写入的值是错误的，这时候就需要加锁来保持数据一致性。

通过使用Lock来控制一段代码在同一时间只能被一个进程执行。Lock对象的两个方法，acquire()用来获取锁，release()用来释放锁。当一个进程调用acquire()时，如果锁的状态为unlocked，那么会立即修改为locked并返回，这时该进程即获得了锁。如果锁的状态为locked，那么调用acquire()的进程则阻塞。

　　

• lock = multiprocessing.Lock()： 创建一个锁

  　　

• lock.acquire() ：获取锁

  　　

• lock.release() ：释放锁

  　　

• with lock：自动获取、释放锁 类似于 with open() as f:

  　　

import multiprocessingimport timedef add(num, value):
　　 print('add{0}:num={1}'.format(value, num))
　　 for i in range(0, 2):
　　 num += value print('add{0}:num={1}'.format(value, num))
　　 time.sleep(1)if __name__ == '__main__':
　　 lock = multiprocessing.Lock()
　　 num = 0
　　 p1 = multiprocessing.Process(target=add, args=(num, 1))
　　 p2 = multiprocessing.Process(target=add, args=(num, 2))
　　 p1.start()
　　 p2.start()

add1:num=0add1:num=1add2:num=0add2:num=2add1:num=2add2:num=4

import multiprocessingimport timedef add(num, value, lock):
　　 try:
　　 lock.acquire()
　　 print('add{0}:num={1}'.format(value, num))
　　 for i in range(0, 2):
　　 num += value print('add{0}:num={1}'.format(value, num))
　　 time.sleep(1)
　　 except Exception as err:
　　 raise err finally:
　　 lock.release()if __name__ == '__main__':
　　 lock = multiprocessing.Lock()
　　 num = 0
　　 p1 = multiprocessing.Process(target=add, args=(num, 1, lock))
　　 p2 = multiprocessing.Process(target=add, args=(num, 2, lock))
　　 p1.start()
　　 p2.start()

add1:num=0add1:num=1add1:num=2add2:num=0add2:num=2add2:num=4

五、进程池Pool

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

　　

1. Pool类语法说明

　　参数说明：

• processes：工作进程数目，如果 processes 为 None，则使用 os.cpu_count() 返回的值。

  　　

• initializer：如果 initializer 不为 None，则每个工作进程将会在启动时调用 initializer(*initargs)。

  　　

• maxtasksperchild：一个工作进程在它退出或被一个新的工作进程代替之前能完成的任务数量，为了释放未使用的资源。

  　　

• context：用于指定启动的工作进程的上下文。

  　　

• apply(func[, args[, kwds]])：阻塞方式。

  　　

• apply_async(func[, args[, kwds]])：非阻塞方式。使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表

  　　

　　方法名说明close()关闭Pool，使其不再接受新的任务terminate()不管任务是否完成，立即终止join()主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用

2. Pool实例

# -*- coding:utf-8 -*-from multiprocessing import Poolimport os, time, randomdef worker(msg):
　　 t_start = time.time()
　　 print("%s开始执行,进程号为%d" % (msg,os.getpid()))
　　 # random.random()随机生成0~1之间的浮点数
　　 time.sleep(random.random()*2) 
　　 t_stop = time.time()
　　 print(msg,"执行完毕，耗时%0.2f" % (t_stop-t_start))po = Pool(3) # 定义一个进程池，最大进程数3for i in range(0,10):
　　 # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
　　 # 每次循环将会用空闲出来的子进程去调用目标
　　 po.apply_async(worker,(i,))print("----start----")po.close() 
　　 # 关闭进程池，关闭后po不再接收新的请求po.join() 
　　 # 等待po中所有子进程执行完成，必须放在close语句之后print("-----end-----")

----start----
　　0开始执行,进程号为21466
　　1开始执行,进程号为21468
　　2开始执行,进程号为21467
　　0 执行完毕，耗时1.01
　　3开始执行,进程号为21466
　　2 执行完毕，耗时1.24
　　4开始执行,进程号为21467
　　3 执行完毕，耗时0.56
　　5开始执行,进程号为21466
　　1 执行完毕，耗时1.68
　　6开始执行,进程号为21468
　　4 执行完毕，耗时0.67
　　7开始执行,进程号为21467
　　5 执行完毕，耗时0.83
　　8开始执行,进程号为21466
　　6 执行完毕，耗时0.75
　　9开始执行,进程号为21468
　　7 执行完毕，耗时1.03
　　8 执行完毕，耗时1.05
　　9 执行完毕，耗时1.69
　　-----end-----

3. 进程池中的Queue

　　而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：RuntimeError: Queue objects should only be shared between processes through inheritance.

　　下面的实例演示了进程池中的进程如何通信：

# -*- coding:utf-8 -*-# 修改import中的Queue为Managerfrom multiprocessing import Manager,Poolimport os,time,randomdef reader(q):
　　 print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
　　 for i in range(q.qsize()):
　　 print("reader从Queue获取到消息：%s" % q.get(True))def writer(q):
　　 print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
　　 for i in "itcast":
　　 q.put(i)if __name__=="__main__":
　　 print("(%s) start" % os.getpid())
　　 q = Manager().Queue() # 使用Manager中的Queue
　　 po = Pool()
　　 po.apply_async(writer, (q,))
　　 time.sleep(1) # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据
　　 po.apply_async(reader, (q,))
　　 po.close()
　　 po.join()
　　 print("(%s) End" % os.getpid())

(11095) start
　　writer启动(11097),父进程为(11095)reader启动(11098),父进程为(11095)reader从Queue获取到消息：i
　　reader从Queue获取到消息：t
　　reader从Queue获取到消息：c
　　reader从Queue获取到消息：a
　　reader从Queue获取到消息：s
　　reader从Queue获取到消息：t(11095) End

六、进程、线程对比

1. 功能

　　定义的不同

• 进程是系统进行资源分配和调度的一个独立单位.

  　　

• 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

  　　

2. 区别

• 一个程序至少有一个进程,一个进程至少有一个线程.
  -线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
  -进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
  
• 线线程不能够独立执行，必须依存在进程中
• 可以将进程理解为工厂中的一条流水线，而其中的线程就是这个流水线上的工人
  

3. 优缺点

• 线程：线程执行开销小，但不利于资源的管理和保护
• 进程：进程执行开销大，但利于资源的管理和保护

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。