Python基础知识学习-第12天

25_2.多线程之_thread模块

编写一段子程序，依次执行两次：

"""
单线程示例
"""
import time

def worker(n):
    print('子程序开始于：{}'.format(time.ctime()))
    time.sleep(n)
    print('子程序结束于：{}'.format(time.ctime()))

def main():
    print('[主程序开始于：{}'.format(time.ctime()))
    worker(4)
    worker(2)
    print('[主程序结束于：{}'.format(time.ctime()))

if __name__ == '__main__':
    main()

输出：

[主程序开始于：Sun Feb 23 16:25:22 2020
子程序开始于：Sun Feb 23 16:25:22 2020
子程序结束于：Sun Feb 23 16:25:26 2020
子程序开始于：Sun Feb 23 16:25:26 2020
子程序结束于：Sun Feb 23 16:25:28 2020
[主程序结束于：Sun Feb 23 16:25:28 2020

如果想让两次子程序并行运行，引入_thread模块：

"""
多线程示例
"""
import time
import _thread

def worker(n):
    print('子程序开始于：{}'.format(time.ctime()))
    time.sleep(n)
    print('子程序结束于：{}'.format(time.ctime()))

def main():
    print('[主程序开始于：{}'.format(time.ctime()))
    # 开始并行线程
    # 第一个参数是要运行的函数名，不加括号
    # 第二个参数是要运行的函数的参数，以元组的形式，如果只有一个参数，要加逗号
    _thread.start_new_thread(worker, (4,))
    _thread.start_new_thread(worker, (2,))
    print('[主程序结束于：{}'.format(time.ctime()))

if __name__ == '__main__':
    main()

输出：

[主程序开始于：Sun Feb 23 16:33:52 2020
[主程序结束于：Sun Feb 23 16:33:52 2020
子程序开始于：Sun Feb 23 16:33:52 2020

跟预想的不一样，因为_thread模块没有控制进程结束机制：

"""
多线程示例
"""
import time
import _thread

def worker(n):
    print('子程序开始于：{}'.format(time.ctime()))
    time.sleep(n)
    print('子程序结束于：{}'.format(time.ctime()))

def main():
    print('[主程序开始于：{}'.format(time.ctime()))
    # 开始并行线程
    # 第一个参数是要运行的函数名，不加括号
    # 第二个参数是要运行的函数的参数，以元组的形式，如果只有一个参数，要加逗号
    _thread.start_new_thread(worker, (4,))
    _thread.start_new_thread(worker, (2,))
    time.sleep(6)
    print('[主程序结束于：{}'.format(time.ctime()))

if __name__ == '__main__':
    main()

输出：

[主程序开始于：Sun Feb 23 16:37:21 2020
子程序开始于：Sun Feb 23 16:37:21 2020
子程序开始于：Sun Feb 23 16:37:21 2020
子程序结束于：Sun Feb 23 16:37:23 2020
子程序结束于：Sun Feb 23 16:37:25 2020
[主程序结束于：Sun Feb 23 16:37:27 2020

主程序执行的时间由time.sleep()里面的参数控制。

25_3.多线程之threading模块

使用threading模块改造上面的实例：

"""
threading模块示例
"""
import time
import threading

def worker(n):
    print('子程序开始于：{}'.format(time.ctime()))
    time.sleep(n)
    print('子程序结束于：{}'.format(time.ctime()))

def main():
    print('[主程序开始于：{}'.format(time.ctime()))
    # 开始并行线程
    # 第一个参数是要运行的函数名，不加括号
    # 第二个参数是要运行的函数的参数，以元组的形式，如果只有一个参数，要加逗号
    # _thread.start_new_thread(worker, (4,))
    # _thread.start_new_thread(worker, (2,))
    # time.sleep(6)

    threads = []
    t1 = threading.Thread(target=worker, args=(4,))
    threads.append(t1)
    t2 = threading.Thread(target=worker, args=(2,))
    threads.append(t2)

    for t in threads:
        t.start()

    print('[主程序结束于：{}'.format(time.ctime()))

if __name__ == '__main__':
    main()

输出：

[主程序开始于：Mon Feb 24 10:10:38 2020
子程序开始于：Mon Feb 24 10:10:38 2020
子程序开始于：Mon Feb 24 10:10:38 2020[主程序结束于：Mon Feb 24 10:10:38 2020

子程序结束于：Mon Feb 24 10:10:40 2020
子程序结束于：Mon Feb 24 10:10:42 2020

和预想的不一样。子程序还没结束主程序就已经结束了。可加入t.join():

"""
threading模块示例
""&