python学习笔记 - 并发编程

进程

运行中的程序就是进程, 进程是计算机中最小的资源分配单位
开启多进程会有开销, 所以并不是所有问题都适合多进程解决

Process源码

class Process(object):
    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
        self.name = ''
        self.daemon = False
        self.authkey = None
        self.exitcode = None
        self.ident = 0
        self.pid = 0
        self.sentinel = None

    def run(self):
        pass

    def start(self):
        pass

    def terminate(self):
        pass

    def join(self, timeout=None):
        pass

    def is_alive(self):
        return False

开启子进程

from multiprocessing import Process

def func():
	pass

# 开启一个子进程
Process(target=func).start()

# 开启多个子进程
for i in range(10):
	p = Process(target=func)
	p.start()

• 验证父子进程之间的数据不能共享

from multiprocessing import Process

"""子进程也会开辟自己的内存空间, 将自己的变量存在自己的内存空间中"""

n = 100

def func():
    global n
    n = 0

if __name__ == '__main__':
	# 启动子进程, target参数获取执行的函数名, args参数获取函数所需的参数(使用元祖)
    Process(target=func).start()
    print(n)

• 主进程会等待子进程结束后再结束

from multiprocessing import Process
import time

"""父进程需要等待子进程代码结束后回收子进程占用资源, 所以要等到子进程接收后再结束自己"""

def func():
	time.sleep(10)
	print('子进程结束')

if __name__ == '__main__':
	Process(target=func).start()
	time.sleep(1)
	print('父进程结束')

• 子进程执行异步, 没有顺序

from multiprocessing import Process

"""执行结果顺序随机, 并不按照代码顺序"""

def func(n):
    print('>'*n)

if __name__ == '__main__':
    Process(target=func, args=(1,)).start()
    Process(target=func, args=(5,)).start()
    Process(target=func, args=(3,)).start()
    Process(target=func, args=(2,)).start()

实现子进程阻塞

from multiprocessing import Process
import time

def func(n):
    time.sleep(1)
    print('>' * n)

if __name__ == '__main__':
    l = []
    for i in range(10):
        p = Process(target=func, args=(i,))
        p.start()
        l.append(p)

    for j in l:
        p.join() # 阻塞, 会等待子进程结束后再执行后边的代码

    print('都结束了')

守护进程

守护进程也是一个子进程
当主进程的**代码**执行完毕之后自动结束的子进程叫做守护进程

from multiprocessing import Process
import time

def daemon_func():
    while True:
        print('守护进程')
        time.sleep(0.5)

def func():
    for i in range(5):
        print('非守护进程')
        time.sleep(1)

if __name__ == '__main__':
    Process(target=func).start()
    p = Process(target=daemon_func)
    p.daemon = True # 将daemon设置为True, 即守护进程模式
    p.start()
    for i in range(3):
        print('主进程')
        time.sleep(1)

守护进程报活

from multiprocessing import Process
import time

def daemon_func():
    while True:
        print('守护进程')
        time.sleep(0.5)

def func():
    for i in range(5):
        print('非守护进程')
        time.sleep(1)

if __name__ == '__main__':
    p2 = Process(target=func)
    p2.start()
    p = Process(target=daemon_func)
    p.daemon = True # 将daemon设置为True, 即守护进程模式
    p.start()
    for i in range(3):
        print('主进程')
        time.sleep(1)
    p2.join() 

---

线程

---

协程