python多线程和多进程的实现

一、python多线程

1、python单线程

import time                


def say_hello():                
    print("今天又是美好的一天")                
    time.sleep(1)                


for i in range(5):                
    say_hello()                

2、 python 多线程的第一种实现方式

import threading 
import time 


def say_hello(): 
    print("今天又是美好的一天") 
    time.sleep(1) 


for i in range(5): 
    t = threading.Thread(target=say_hello) 
    t.start()  # 启动线程，即让线程开始执行 

3、python单线程和python多线程的区别

• 查看不同，就可以看出，多线程的创造就是使用了threading.Tread()这个模块，target=say_hello .是内部的参数。target翻译成中文是目标的意思。 say_hello这个函数名就是目标。 把这个函数名传入到target里面，每次调用 t = threading.Thread(target=say_hello)，就是创建了一个新的线程。 然后 通过start来启动，这样就实现了多线程。 上面一共循环5次，就是创建了5个线程. 加上主线程，就是6个线程。可以先猜一下上面左右两个程序运行的现象。
• 要注意的一点是，say_hello中的time.sleep，是阻碍当前的线程，即当前循环产生的线程。不能阻碍下一次循环产生的新线程，所以右边的程序，可以很快打印出 ‘今天又是美好的一天’，左边的程序，因为是单线程，所以每隔一秒，打印出今天又是美好的一天。类比一下，单线程是一个人说了5次， 多线程是一个人找了5个人，然后5个人都说了一次。

4、多线程传参 的方式

之前的多线程实现方式，就是把函数名传入到线程模块里（target=）,从而会新生成的一个线程来运行。但是一个函数运行，经常是需要给函数传入参数的。这个在线程模块里，是通过args这个参数来传入的,查看源码可以看到注释
注意一下，target 是会被一个run()的方法调用的

如下面程序展示的，就是把args这个元组里的10传入t1里面的work1函数，20传入t2里面的work2。

from threading import Thread
import time 


def work1(nums): 
    print("----in work1--nums=%d-" % nums) 


def work2(nums): 
    print("----in work2--nums=%d-" % nums) 


t1 = Thread(target=work1, args=(10,)) 
t1.start() 

t2 = Thread(target=work2, args=(20,)) 
t2.start() 

如果传如多个参数，就是

from threading import Thread
import time

def work1(num1, num2):
    print("----in work1--num1=%d,num2=%d-" % (num1, num2))


def work2(num1, num2, num3):
    print("----in work1--num1=%d,num2=%d,num3=%d-" % (num1, num2, num3))

t1 = Thread(target=work1, args=(11, 22))
t1.start()

t2 = Thread(target=work2, args=(33, 44, 55))
t2.start()

之前都是args逐个分配，顺序给到num1和num2,但是如果指定给num2这个值给22，这种怎么操作呢，如下所示。参数有三个，专门给num2这个值给22,m给100，就要用到字典的方式，key是给的变量的名字，value是给的变量的值

from threading import Thread


def work1(num1, num2, m):
    print("----in work1--num1=%d,num2=%d,m=%d-" % (num1, num2, m))


def work2(num1, num2, num3, n):
    print("----in work1--num1=%d,num2=%d,num3=%d,n=%d-" % (num1, num2, num3, n))


t1 = Thread(target=work1, args=(11,), kwargs={"m": 100, "num2": 22})
t1.start()

t2 = Thread(target=work2, args=(33, 44, 55), kwargs={"n": 200})
t2.start()

总结：在使用Thread创建线程的时候，args是传递一个元组，元组中的数据个数与target指定的函数形参个数、顺序一直，kwargs是一个字典 里面的key当做形参中的变量名字，value是给这个形参传递的数值，先用args的赋值顺序的，后用字典赋值，不用考虑到顺序。

5、多线程实现的第二种方式

上面的实现方式是使用threading.Thread()创建一个对象，并且在使用target来指定一个函数，作为线程要执行的代码。

可以看出，target保存的目标函数，是通过run()这个方法实现的，另一种实现方式，就是通过继承thread这个模块，然后重写run（）这个方法。name也就是线程的名字。

封装性更好的一种创建线程的方式是：

import threading 
import time 

class MyThread(threading.Thread): 
    def run(self): 
        for i in range(3): 
            msg = "I'm "+ self.name + ' @ '+str(i) #  name属性中保存的是当前线程的名字

            print(msg) 
            time.sleep(1) 


if __name__ == '__main__': 
    t = MyThread()  
    t.start()  

当线程启动时，它会执行run方法。
run方法里有一个循环，循环三次。
在每次循环中，它创建一个消息字符串msg，该字符串包含当前线程的名字（通过self.name获取）和循环的当前迭代次数i。

然后，它打印这条消息。
接着，线程暂停（休眠）1秒。
在if name == ‘main’:部分，代码创建了MyThread类的一个实例 t，并调用start方法启动这个线程。一旦线程启动，它就会执行run方法中的代码。

所以，当你运行这段代码时，你会看到如下输出（线程名字可能会有所不同，因为它是由Python自动分配的）：

总结下通用实现的步骤

1、 定义一个新的类，继承Thread类
2、 在这个类中实现run方法
3、在run方法中写如要执行的代码
4、当使用这个类创建一个对象后，调用对象的start方法就可以让这个线程执行，且会自动执行run方法的代码

结论：

1、 每个线程默认有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。
2、当线程的run()方法结束时表示该线程结束
3、既然run方法是个示例方法，那么也就意味着可以调用本类中的其它实例方法，从而能够编写出较为复杂的功能

二、python多进程

1、多进程实现的方法一

线程是threading.Thread(target=函数名) 这种实现多线程，
进程是通过multiprocessing.Process(target=函数名) 来实现多进程

• 如下面程序

from multiprocessing import Process
import time
 
def test():
    """子进程单独执行的代码"""
    while True:
        print('---test---')
        time.sleep(1)
 
if __name__ == '__main__':
    p=Process(target=test)
    p.start()
    # 主进程单独执行的代码
    while True:
        print('---main---')
        time.sleep(1)

当运行这段代码时，你会看到—test—和—main—交替打印出来，每个消息之间间隔1秒。这是因为子进程和主进程是并发执行的，它们会几乎同时打印出各自的消息。

需要注意的是，由于并发执行的特性，你有时可能会看到—test—和—main—的打印顺序不是完全交替的，但这并不影响两个进程各自的行为。

另外，由于这两个进程都是无限循环，所以这个程序将一直运行下去，除非你手动停止它。在实际应用中，你可能需要添加一些条件来优雅地终止这些进程。

小结：

• 1、 通过额外创建一个进程，可以实现多任务
  2、使用进程实现多任务的流程：
  3、创建一个Process对象，且在创建时通过target指定一个函数的引用
  4、当调用start时，会真正的创建一个子进程

常用进程的方法

start()：启动子进程实例（创建子进程）
is_alive()：判断子进程是否还在活着
join([timeout])：是否等待子进程执行结束，或等待多少秒
terminate()：不管任务是否完成，立即终止子进程用

2、多进程实现的方法二

1、参考多线程的类实现

import threading


class Task(threading.Thread):
    def run(self):
        """子线程要执行的代码"""
        pass
    
t = Task()
t.start()

2、多进程通过类实现如下
也是类继承 Process后，重写run ,然后通过start方法来调用

from multiprocessing import Process 
import time 
 
class MyNewProcess(Process): 
    def run(self): 
        while True: 
            print('---1---') 
            time.sleep(1) 
 
if __name__=='__main__': 
    p = MyNewProcess() 
    # 调用p.start()方法，p会先去父类中寻找start()，然后在Process的start方法中调用run方法

    p.start() 
 
    while True: 
        print('---Main---') 
        time.sleep(1) 

3、 多进程实现小结:

1、创建多进程的流程

• 自定义一个类，继承Process类
• 实现run方法
• 通过自定义的类，创建实例对象
• 调用实例对象的start方法

2、对比

• 自定义继承Process类的方式比 直接创建Process对象 要稍微复杂一些，但是可以用来实现更多较为复杂逻辑的功能

3、建议

• 如果想快速的实现一个进程，功能较为简单的话，可以直接创建Process的实例对象
• 如果想实现一个功能较为完整、逻辑较为复杂的进程，可以自定义继承Process类 来实现

3、多进程传递参数

和多线程的实现一样，也是通过
Process(target=run_proc, args=(‘test’,18), kwargs={“m”:20})这种，用 args（元组）和kwargs（字典）来实现的。

如下

from multiprocessing import Process  
import os  
from time import sleep  


def 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()  

子进程要执行的代码是run_proc这个函数：

• 1、 run_proc 这个函数是子进程要执行的代码。

• 2、 它接受三个参数：name、age和**kwargs。其中name和age是位置参数，**kwargs是关键字参数，允许传递任意数量的关键字参数。

• 3、在函数内部，它有一个循环，循环10次。每次循环中，它打印当前子进程的名称、年龄和进程ID，以及所有传入的关键字参数。

• 4、然后，它让子进程休眠0.2秒。

主进程要执行的代码里，主程序的入口是这样的

• 1、使用Process类创建一个子进程对象p。

• 2、target=run_proc：指定子进程要执行的函数。

• 3、args=(‘test’, 18)：传递给run_proc函数的位置参数。依次传给name 和age

• 4、kwargs={“m”: 20}：传递给run_proc函数的关键字参数。

• 5、p.start()：启动子进程。

• 6、sleep(1)：主进程休眠1秒。

• 7、p.terminate()：尝试终止子进程。注意，这并不一定意味着子进程会立即停止。它只是发送一个终止信号给子进程，子进程需要在适当的时候响应这个信号。

• 8、p.join()：主进程等待子进程结束。这里需要注意的是，即使调用了p.terminate()，p.join()仍然会等待子进程真正结束，因为p.terminate()不是一下子结束子进程。

三、python多进程 和多线程之间的注意点

1、多线程之间共享全局变量，多进程之间不共享全局变量

• 多线程之间是共享的

import threading
import time

nums = []


def task1():
    for i in range(3):
        nums.append(i)
    print("task1 中 nums:", nums)
    print("task1 即将结束")


def task2():
    print("task2 中 nums:", nums)
    print("task2 即将结束")


t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)
t1.start()
time.sleep(2)
t2.start()

2、多进程之间变量是不共享的

from multiprocessing import Process
import os
import time

nums = [11, 22]


def work1():
    """子进程要执行的代码"""
    print("111111in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
    for i in range(3):
        nums.append(i)
        time.sleep(1)
        print("222222in process1 pid=%d ,nums=%s" % (os.getpid(), nums))


def work2():
    """子进程要执行的代码"""
    print("333333in process2 pid=%d ,nums=%s" % (os.getpid(), nums))


if __name__ == '__main__':
    p1 = Process(target=work1)
    p1.start()

    time.sleep(2)

    p2 = Process(target=work2)
    p2.start()

3、多进程之间变量是不共享的,但是如果我们需要共享的话，就需要进程间通信（IPC）

• 例如之前学习的网络编程udp、tcp，其实就是一种实现多进程间数据共享的方式，只是它通过套接字（socket）实现了不同电脑上的进程间通信

• 如果在一台电脑上不同进程间通信，就可以用其它的方式实现（知道即可，不需要深入研究，研究操作系统时才需要深入研究它们）：

  • 文件（一个进程写入到文件，一个进程从文件中读取）
  • 共享内存
  • 管道

1、 python 中常用的两种传递进程数据的方式

 -  1、multiprocessing模块的Queue实现多进程之间的数据传递
 -  2、multiprocessing模块提供的Pool方法里的Queu实现多进程之间的数据传递

2、使用multiprocessing模块的Queue实现多进程之间的数据传递

from multiprocessing import Queue
q = Queue(3)  # 初始化一个Queue对象，最多可接收三条put消息
q.put("消息1")
q.put("消息2")
print(q.full())  # False
q.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())

from multiprocessing import Process
import os
import time
from multiprocessing import Queue
nums = [11, 22]
def work1(q):
    """子进程要执行的代码"""
    print("111111in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
    for i in range(3):
        nums.append(i)
        time.sleep(1)
        print("222222in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
        q.put("-----work1------")
def work2(q):
    """子进程要执行的代码"""
    print("333333in process2 pid=%d ,nums=%s" % (os.getpid(), nums))
    print(q.get())
if __name__ == '__main__':
    q = Queue(5)  # 初始化一个Queue对象，最多可接收5条put消息
    p1 = Process(target=work1, args=(q,))
    p1.start()

    time.sleep(2)

    p2 = Process(target=work2, args=(q,))
    p2.start()

3、使用multiprocessing模块的pool方法里的Queue来传输数据–参考下文，先介绍pool线程池

4、使用pool方法创建进程池

• 当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。
• 初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务

这个要在linux环境下运行

from multiprocessing import Pool 
import time 

'''
设置跑10个进程，但是进程池最多放2个进程，即同时运行的就2两个。 
每个进程就打印这个是第几个进程，第一次的进程就打印-----------0-----------,打印3次

'''


def worker(num): 
    for i in range(3): 
        print('-----------{}-----------'.format(num))
        time.sleep(1)


# 表示进程池中最多有2个进程一起执行
pool = Pool(2)

for i in range(10):
    print('======{}======'.format(i))
    # 向进程中添加任务
    # 注意：如果添加的任务数量超过了进程池中进程的个数的话，那么就不会接着往进程池中添加，
    #       如果还没有执行的话，他会等待前面的进程结束，然后在往
    # 进程池中添加新进程
    pool.apply_async(worker, (i,))

pool.close()  # 关闭进程池
pool.join()  # 主进程在这里等待，只有子进程全部结束之后，在会开启主线程

小结：

• apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；
• close()：关闭Pool，使其不再接受新的任务；
• terminate()：不管任务是否完成，立即终止；
• join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；

5、pool进程池中使用Queue

• 之前是使用multiprocessing模块的Queue实现多进程之间的数据传递

• 如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：

  • RuntimeError: Queue objects should only be shared between processes through inheritance.

# -*- coding:utf-8 -*-

# 修改import中的Queue为Manager
from multiprocessing import Manager, Pool
import os, time

def 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())