python多进程、守护进程、多线程、守护线程、线程池

多进程 Process

from time import time, sleep
from multiprocessing import Process
from os import getpid
from random import randint


def download_task(filename):
    print('%s开始下载...,进程号[%d]' % (filename, getpid()))
    download_time = randint(5, 10)
    sleep(download_time)
    print('%s下载完成，花费时间为%.2f秒' % (filename, download_time))


def main():
    start = time()
    p1 = Process(target=download_task, args=('python课程设计',))
    p2 = Process(target=download_task, args=('思想品德',))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    end = time()
    print('下载任务完成，花费时间为%.2f秒' % (end - start))

if __name__ == '__main__':
    main()

运行结果：

守护进程

参考：守护进程

https://blog.csdn.net/u013210620/article/details/78710532

代码如下：

from multiprocessing import Process
from time import sleep
from os import getpid


def foo(arg):
    print('%s is runing...,进程号[%d]' % (arg, getpid()))
    sleep(3)
    print('%s is done' % arg)


def foo1(arg):
    print('%s is runing...,进程号[%d]' % (arg, getpid()))
    sleep(3)
    print('%s is done' % arg)


def main():
    p1 = Process(target=foo, args=('守护子进程',))
    p2 = Process(target=foo1, args=('子进程',))
    p1.daemon = True #True就是将p1设置为守护进程，默认为False，非守护的子进程
    p1.start()
    p2.start()
    sleep(1)
    print('主进程')#此时主进程运行结束但未退出，p1守护子进程立刻结束，p2继续运行

if __name__ == '__main__':
    main()

运行结果：

原因如下:由于p1,p2都是子进程，需要开辟内存空间，需要耗费时间，所以会优先输出‘主进程’,由于p1是守护子进程，p2是非守护子进程，当主进程执行完毕（注意主进程还没有退出，因为还有p2非守护子进程），p1守护子进程也就退了，但是还有一个p2非守护子进程，所以p2会执行自己的代码任务，当p2执行完毕，那么主进程也就退出了，进而整个程序就退出了。
p1随着主进程（也就是主代码运行到最后）运行结束，不管p1是否运行与否，都直接把p1杀掉。
守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

多线程 Thread

from threading import Thread
from time import time, sleep
from random import randint
from os import getpid


def download_task(filename):
    print('%s开始下载...,进程号[%d]' % (filename, getpid()))
    download_time = randint(5, 10)
    sleep(download_time)
    print('%s下载完成，花费时间为%.2f秒' % (filename, download_time))


def main():
    start = time()
    p1 = Thread(target=download_task, args=('python课程设计',))
    p2 = Thread(target=download_task, args=('思想品德',))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    end = time()
    print('下载任务完成，花费时间为%.2f秒' % (end - start))

if __name__ == '__main__':
    main()

运行结果：

守护线程

参考：守护线程

https://blog.csdn.net/u012063703/article/details/51601579
https://blog.csdn.net/u013210620/article/details/78710532

代码如下：

from threading import Thread
from os import getpid
from time import sleep


def foo(arg):
    print('%s is running...,进程号[%d]' % (arg, getpid()))
    sleep(1)
    print('%s is done' % arg)


def foo1(arg):
    print('%s is running...,进程号[%d]' % (arg, getpid()))
    sleep(3)
    print('%s is done' % arg)


def main():
    t1 = Thread(target=foo, args=('守护线程',))
    t2 = Thread(target=foo1, args=('子线程1',))
    t1.daemon = True
    #t1.setDaemon(True)
    t1.start()
    t2.start()
    print('主线程')#此时主线程并未运行结束，因为非守护子线程t2还没有运行结束

if __name__ == '__main__':
    main()

运行结果：

原因是： t1是守护子线程，t2非守护子线程，跟主线程使用一块内存，所以会输 出t1,t2子线程的任务代码，由于t1,t2都有睡眠时间，所以执行主线程代码，然后对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕，所以会执行t1,t2睡眠后的任务代码（即使t1是守护子线程），然后程序退出。

我们会问为什么t1守护子线程，也会执行sleep后的代码，不是说主线程代码执行完毕，守护线程就被干掉了吗？这里要注意是对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕，当时t2还没执行完毕

这里是主线程运行完毕时而守护子线程还没结束的代码：

from threading import Thread
from os import getpid
from time import sleep


def foo(arg):
    print('%s is running...,进程号[%d]' % (arg, getpid()))
    sleep(8)
    print('%s is done' % arg)


def foo1(arg):
    print('%s is running...,进程号[%d]' % (arg, getpid()))
    sleep(3)
    print('%s is done' % arg)


def main():
    t1 = Thread(target=foo, args=('守护线程',))
    t2 = Thread(target=foo1, args=('子线程1',))
    t1.daemon = True
    #t1.setDaemon(True)
    t1.start()
    t2.start()
    print('主线程')#此时主线程并未运行结束，因为非守护子线程t2还在运行

if __name__ == '__main__':
    main()

运行结果：

t1守护子线程在t2运行结束时(主线程此时运行完毕)，立刻和主线程同时退出。

---

守护进程和守护线程：

---

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁
需要强调的是：运行完毕并非终止运行

1.对主进程来说，运行完毕指的是主进程代码运行完毕
2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

详细解释：
1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

线程池 ThreadPoolExecutor

代码如下

from time import time, sleep
from random import randint
from concurrent.futures import ThreadPoolExecutor
from os import getpid


def foo1(num):
    stop_time = randint(2, 5)
    sleep(stop_time)
    print('任务%d完成，耗时%d秒,进程号[%d]' % (num, stop_time, getpid()))


def main():
    pool = ThreadPoolExecutor(max_workers=20)
    futures = []
    start = time()
    for i in range(5):
        future = pool.submit(foo1, int(i))
        futures.append(future)

    for future in futures:
        future.result()

    end = time()
    print('程序耗时%d秒' % (end - start))
    pool.shutdown()

if __name__ == '__main__':
    main()

运行结果：