python多任务并发，并行与线程介绍与使用

• • 并行与并发介绍
  • 多任务的介绍
  • • 多任务简单实现
  • 查看线程数量
  • 验证子线程的创建与执行

并行与并发介绍

       •并发：两个或多个事件在同一时间间隔内发生，这些事件在宏观上是同时发生的，在微观上是交替发生的， 操作系统的并发性指系统中同时存在着多个运行的程序
       •并行：两个或多个事件在同一时刻发生
       •一个单核(CPU)同一时刻只能执行一个程序，因此操作系统会协调多个程序使它们交替进行（这些程序在宏观上是同时发生的，在微观上是交替进行的(并发)）,单核系统同时执行多个程序一定是具有并发性的

多任务的介绍

       •简单地说，就是操作系统可以同时执行多个任务，生活中有很多的场景中的事情就是同时进行的，比如开车的时候手和脚共同来驾驶汽车，再比如吃饭时手和嘴巴是同时进行的

程序代码模拟多任务：

import time


def study():
    for i in range(3):
        print('学习第{}次'.format(i))
        time.sleep(1)


def book():
    for j in range(3):
        print('看书第{}次'.format(j))
        time.sleep(1)


if __name__ == '__main__':
    study()
    book()

运行结果：

       •由上图得：两个函数是按照先后顺序执行的，不能实现同时执行，此时需要多任务，可以使多个任务同时进行，提高效率
       •图解多任务：

       •上述的实际情况是四个应用程序是可同时执行的，但是多个应用“同时”运行时，并不是真正地同时运行，而是按照时间片轮转的原理进行的(并行执行)

多任务简单实现

       •并发：
        假的多任务，CPU数小于当前执行的任务数
       •并行：
        真的多任务，CPU数大于等于当前执行的任务数
程序实现：

import threading
import time


def demo():
    print('Hello World')
    time.sleep(1)


def main():
    for i in range(5):
        t = threading.Thread(target=demo)
        t.start()


if __name__ == '__main__':
    main()

运行结果：

       •main()函数中为主线程，demo()函数为子线程；target参数是需要执行的任务，即为(demo()函数)
与上一段代码结合修改：

import threading
import time


def study():
    for i in range(3):
        print('学习第{}次'.format(i))
        time.sleep(1)


def book():
    for j in range(3):
        print('看书第{}次'.format(j))
        time.sleep(1)


if __name__ == '__main__':
    t1 = threading.Thread(target=study) #是study 不是study()
    t2 = threading.Thread(target=book)  #是book  不是book()
    t1.start()
    t2.start()

运行结果：

       •由显示结果可得，study()和book()两个函数是同时执行的，此即为多任务，在代码中，t1和t2两个线程是同时执行、不分先后顺序的
       •子线程结束之后主线程才会结束，代码验证：

import threading
import time


def demo():
    for i in range(5):
        print('Hello World')
        time.sleep(1)


def main():
    t = threading.Thread(target=demo)
    t.start()
    print('主线程')


if __name__ == '__main__':
    main()

运行结果：

       •要想主线程执行结束后直接结束程序运行，可增加守护线程
       •守护线程：setDaemon(True)
代码如下：

import threading
import time


def demo():
    for i in range(5):
        print('Hello World')
        time.sleep(1)


def main():
    t = threading.Thread(target=demo)
    # 守护线程
    t.setDaemon(True)
    t.start()
    print('主线程')


if __name__ == '__main__':
    main()

运行结果：

       •上图可看出，只打印了一次Hello World，主线程并没有等待子线程执行结束再结束，而是直接执行结束，所以守护线程不会等子线程结束，而是直接结束

       •改进程序，使子线程结束之后主线程再继续运行：

import threading
import time


def demo():
    for i in range(5):
        print('Hello World')
        time.sleep(1)


def main():
    t = threading.Thread(target=demo)
    t.start()
    # 等待子线程执行结束，主线程继续向下运行
    t.join()
    print('主线程')


if __name__ == '__main__':
    main()

运行结果：

       •由上图可以看出主线程等待子线程打印完全部Hello World之后才打印主线程

       •并且，子线程还可以创建子线程
代码测试：

import threading
import time


def demo():
    for i in range(5):
        print('Hello World')
        time.sleep(1)
        t2 = threading.Thread(target=demo1)
        t2.start()


def demo1():
    print('我是子线程的创建的子线程')


def main():
    t = threading.Thread(target=demo)
    t.start()
    # 等待子线程执行结束，主线程继续向下运行
    t.join()
    print('主线程')


if __name__ == '__main__':
    main()

运行结果：

       •可以看出，子线程的子线程也能正常运行，并且穿插在子线程的运行过程中运行

查看线程数量

       •在python的基础函数中，enumerate()函数可以为列表自动创建索引：
代码测试：

list1 = ['y', 'c', 'x']
for i, item in enumerate(list1):
    print(i, item)

运行结果：

       •在多任务中，enumerate()函数可以查看当前线程的数量：
代码测试：

import threading


def demo1():
    for i in range(5):
        print('--demo1-- {}'.format(i))


def demo2():
    for i in range(5):
        print('--demo2-- {}'.format(i))


def main():
    t1 = threading.Thread(target=demo1)
    t2 = threading.Thread(target=demo2)
    t1.start()
    t2.start()
    # 获取当前程序所有的线程
    print(threading.enumerate())


if __name__ == '__main__':
    main()

运行结果：

       •从图中可以看出有两个线程：主线程和线程2

       •多次运行，结果都是不同的，如下运行图示：

       •图示中只有一个主线程

验证子线程的创建与执行

       •当调用Thread时，是不会创建线程
       •当调用Thread创建出来的实例对象的start()方法的时候，才会创建线程以及开始运行这个线程
代码测试：

import threading


def demo():
    for i in range(5):
        print('Hello World')


def main():
    print(threading.enumerate())
    t1 = threading.Thread(target=demo)
    print(threading.enumerate())
    t1.start()
    print(threading.enumerate())


if __name__ == '__main__':
    main()

运行结果：

       •由上图可得，在调用Thread时不会创建子线程，只有在调用start()方法后才会创建线程并执行