筆記-python-多執行緒-深入-1

1.      執行緒池

1.1.    執行緒池：控制同時存在的執行緒數量

threading沒有執行緒池，只能自己控制執行緒數量。

基本有兩種方式：

1. 每間隔一段時間建立一批執行緒
2. 加一層迴圈，進行條件判斷，如果執行緒數量小於預定值則建立新執行緒，否則等待；

使用queue,條件判斷都屬於這種方式。

# 執行緒函式1

def th(num=3):
    print('{} enter th:{}'.format(num, threading.get_ident()))
    print('the main thread is:{}'.format(threading.main_thread()))
    print('th:active thread\'s num is {}'.format(threading.active_count()))
    time.sleep(5)
    print('th end',num)

# 方式1：一批批建立
def multithreads1(*args):
    print('enter multithreads1')
    t_list = list()
    for _ in range(7):
        t_list.append(threading.Thread(target=th, args=(_,),name= 'aaa'))

    for _ in t_list:
        _.daemon = True
        _.start()
    print('from multithreads:',threading.get_ident(),threading.activeCount())
    #print('active threads:',threading.enumerate())
    '''
    for _ in t_list:
        print(type(_))
        _.join()
    '''
    t_list = threading.enumerate()
    print(type(t_list))
    print('t_list:',t_list)
    for _ in t_list:
        if _.name == 'aaa':
            _.join()
    print('main thread end.')

# 方式2：控制總任務數，每次迴圈檢查活動執行緒數，如果較少則建立新執行緒
# 通過訊號量/變數條件控制總迴圈次數
def multithreads2(task_nums=100, max_threads=5, *args):
    task_i = 0
    while task_i < task_nums:
        if threading.active_count() < max_threads:
            t = threading.Thread(target=th, args=(task_i,))
            t.daemon = True
            t.start()
        else:
            time.sleep(2)

'''
# 測active_count()
print('this is in mainthread:\nthread num is {},thread id is {}'.format(threading.activeCount(),threading.get_ident()))

#th(3)
multithreads1()
print('main_thread stop:{}'.format(threading.current_thread()))
'''

# 執行緒呼叫函式
import queue
def th1(num=-1):
    print('enter th1.',num)
    time.sleep(3)
    print('end th1.',num)

# 方式3：
def multithreads3(*args):
    print('enter multithreads3!')
    q = queue.Queue()
    for i in range(3):
        q.put(i)
    thread_num_max = 10

    while True:
        if threading.active_count() <= thread_num_max:
            proxy = q.get()
            if proxy is None:
                print('break')
                break
            thread_t = threading.Thread(target=th1, args=(proxy,))
            thread_t.deamon = True
            thread_t.start()

        t_list = threading.enumerate()
        for _ in t_list:
            if _ is threading.current_thread():
                pass
            else:
                _.join()
        print('active thread number:',threading.active_count())

總結：
1.可以對死亡執行緒進行join
2.一定要注意join方式，否則容易成為單執行緒。

3.activecount 包括主執行緒，是程序內所有的執行緒數。

2.      執行緒返回執行結果

class MyThread(threading.Thread):

    def __init__(self, func, args, name=''):

        threading.Thread.__init__(self)

        self.name = name

        self.func = func

        self.args = args

        self.result = self.func(*self.args)

    def get_result(self):

        try:

            return self.result

        except Exception:

            return None