python多线程编程

这儿主要记录两个函数： threading.Thread.join(),threading.Thread.setDaemon()

• 如果创建主线程，并且设置了Daemon（）为True，那么主线程执行完毕，不会等待子线程，直接结束程序
• join方法的作用是阻塞，让主线程等待子线程结束，join方法可是设置一个timeout参数，即如果主线程等待子线程timeout时间，子线程还没运行结束，那么主线程会强制结束。
• join和setDaemon（True）是作用相反的函数，一个是等待，一个是不用等待

设置守护线程为True

# encoding=utf-8
from threading import Thread
from time import ctime, sleep

def loop(i, sleep_time):
    print('start thread {} at {}'.format(i, ctime()))
    sleep(sleep_time)
    print('end thread {} at {}'.format(i, ctime()))

if __name__ == '__main__':
    thread_ids = list(range(2))
    sleep_times = [4, 2]
    threads = []
    for i in range(2):
        _thread = Thread(target=loop, args=((thread_ids[i], sleep_times[i])))
        threads.append(_thread)

    # 如果设置两个子线程为守护线程，那么主线程一旦执行结束，子线程也会被干掉。还有守护线程的设置需要在start之前
    for i in range(2):
        threads[i].setDaemon(True)
    for i in range(2):
        threads[i].start()
    # 程序如果调用join，那么主线程会等待所有子线程运行结束才会往下继续执行
    # for i in range(2):
    #     threads[i].join()
    print('all threads done! at', ctime())

C:\Users\admin\Anaconda3\python.exe D:/pycharmWorkSpace/learning_python/my_thread.py
start thread 0 at Tue Jul 24 09:58:20 2018
start thread 1 at Tue Jul 24 09:58:20 2018
all threads done! at Tue Jul 24 09:58:20 2018

Process finished with exit code 0

什么也不设置

---

# encoding=utf-8
from threading import Thread
from time import ctime, sleep

def loop(i, sleep_time):
    print('start thread {} at {}'.format(i, ctime()))
    sleep(sleep_time)
    print('end thread {} at {}'.format(i, ctime()))

if __name__ == '__main__':
    thread_ids = list(range(2))
    sleep_times = [4, 2]
    threads = []
    for i in range(2):
        _thread = Thread(target=loop, args=((thread_ids[i], sleep_times[i])))
        threads.append(_thread)

    # 如果设置两个子线程为守护线程，那么主线程一旦执行结束，子线程也会被干掉。还有守护线程的设置需要在start之前
    # for i in range(2):
    #     threads[i].setDaemon(True)
    for i in range(2):
        threads[i].start()
    # 程序如果调用join，那么主线程会等待所有子线程运行结束才会往下继续执行
    # for i in range(2):
    #     threads[i].join()
    print('all threads done! at', ctime())

C:\Users\admin\Anaconda3\python.exe D:/pycharmWorkSpace/learning_python/my_thread.py
start thread 0 at Tue Jul 24 10:03:58 2018
start thread 1 at Tue Jul 24 10:03:58 2018
all threads done! at Tue Jul 24 10:03:58 2018
end thread 1 at Tue Jul 24 10:04:00 2018
end thread 0 at Tue Jul 24 10:04:02 2018

Process finished with exit code 0

设置阻塞，join

---

# encoding=utf-8
from threading import Thread
from time import ctime, sleep

def loop(i, sleep_time):
    print('start thread {} at {}'.format(i, ctime()))
    sleep(sleep_time)
    print('end thread {} at {}'.format(i, ctime()))

if __name__ == '__main__':
    thread_ids = list(range(2))
    sleep_times = [4, 2]
    threads = []
    for i in range(2):
        _thread = Thread(target=loop, args=((thread_ids[i], sleep_times[i])))
        threads.append(_thread)

    # 如果设置两个子线程为守护线程，那么主线程一旦执行结束，子线程也会被干掉。还有守护线程的设置需要在start之前
    # for i in range(2):
    #     threads[i].setDaemon(True)
    for i in range(2):
        threads[i].start()
    # 程序如果调用join，那么主线程会等待所有子线程运行结束才会往下继续执行
    for i in range(2):
        threads[i].join()
    print('all threads done! at', ctime())

C:\Users\admin\Anaconda3\python.exe D:/pycharmWorkSpace/learning_python/my_thread.py
start thread 0 at Tue Jul 24 10:04:37 2018
start thread 1 at Tue Jul 24 10:04:37 2018
end thread 1 at Tue Jul 24 10:04:39 2018
end thread 0 at Tue Jul 24 10:04:41 2018
all threads done! at Tue Jul 24 10:04:41 2018

Process finished with exit code 0

更新

---

在设计多线程编程时候，可能需要获取子线程计算结果。那么，这儿主要记录如何获取多个子线程的结果。
获取子线程的结果可以通过Queue来实现，这是个先进先出的队列，当然也有别的例如优先级队列等。
子线程计算完毕后，将结果放到queue中，其中主线程通过join被阻塞，当所有子线程都运行结束，主线程才到queue中收割子线程计算的结果。

import sys
import threading
import queue

q = queue.Queue()


def worker1(x, y):
    func_name = sys._getframe().f_code.co_name
    print("%s run ..." % func_name)
    q.put((x + y, func_name))


def worker2(x, y):
    func_name = sys._getframe().f_code.co_name
    print("%s run ...." % func_name)
    q.put((x - y, func_name))


if __name__ == '__main__':
    result = list()
    t1 = threading.Thread(target=worker1, name='thread1', args=(10, 5,))
    t2 = threading.Thread(target=worker2, name='thread2', args=(20, 1,))
    print('-' * 50)
    t2.start()
    t1.start()
    t1.join()
    t2.join()
    while not q.empty():
        result.append(q.get())
    print(result)
    for item in result:
        if item[1] == worker1.__name__:
            print("%s 's return value is : %s" % (item[1], item[0]))
        elif item[1] == worker2.__name__:
            print("%s 's return value is : %s" % (item[1], item[0]))
    print('*' * 50)
    # sorted_result = []

    # for item in result:
    #     if item[1]==worker1.__name__:
    #         sorted_result.append(item[0])
    # for item in result:
    #     if item[1]==worker2.__name__:
    #         sorted_result.append(item[0])
    #
    # print(sorted_result)

C:\Users\admin\Anaconda3\python.exe D:/pycharmWorkSpace/learning_python/my_Queue.py
--------------------------------------------------
worker2 run ....
worker1 run ...
[(19, 'worker2'), (15, 'worker1')]
worker2 's return value is : 19
worker1 's return value is : 15
**************************************************

Process finished with exit code 0

参考：
https://blog.csdn.net/kelvinLLL/article/details/70766836
http://www.runoob.com/python3/python3-multithreading.html
https://www.imooc.com/article/16198