selenium+python之python多線程

程序、進程及線程的區別

計算機程序是磁盤中可執行的二進制數據（或者其他類型）他們只有在被讀取到內存中，被操作系統調用才開始他們的生命周期。

進程是程序的一次執行，每個進程都有自己的地址空間，內存，數據棧，以及其他記錄其運行軌跡的輔助數據，操作系統管理再其上面運行的所有進程，並為這些進程公平得分配時間。

線程與進程相似，不同的是所有的線程都運行在同一個進程中，共享相同的運行環境。

 

1.單線程

單線程時，當處理器需要處理多個任務時，必須對這些任務安排執行的順序，並按照這個順序來執行任務。

from time import sleep, ctime


# 聽音樂
def music():
    print('i was listening to music! %s' % ctime())
    sleep(2)


# 看電影
def movie():
    print('i was at the movies! %s' % ctime())
    sleep(5)


if __name__ == '__main__':
    music()
    movie()
    print('all end:', ctime())

增加循環功能：

from time import sleep, ctime


# 聽音樂
def music(func, loop):
    for i in range(loop):
        print('i was listening to music! %s !%s' % (func, ctime()))
        sleep(2)


# 看電影
def movie(func, loop):
    for i in range(loop):
        print('i was listening to music! %s !%s' % (func, ctime()))
        sleep(5)


if __name__ == '__main__':
    music('愛情買賣', 2)
    movie('一代宗師', 2)
    print('all end:', ctime())

給music（）和movie（）兩個函數設置參數：播放文件和播放次數。函數中通過for循環控制播放的次數。

2、多線程

python通過兩個標准庫thread和threading提供對線程的支持。thread提供了低級別的，原始的線程以及一個簡單的鎖。threading基於Java的線程模型設計。鎖（lock）和條件變量（condition）在Java中時對象的基本行為（每個對象都自帶了鎖和條件變量），而在python中則是獨立的對象。

（1）threading模塊

避免使用thread模塊，原因是它不支持守護線程。當主線程退出時，所有的子線程不關他們是否還在工作，都會被強行退出。但是我們並不希望發生這種行為。就要引入守護線程的概念。threading支持守護線程。

from time import sleep, ctime
import threading


# 聽音樂
def music(func, loop):
    for i in range(loop):
        print('i was listening to music! %s !%s' % (func, ctime()))
        sleep(2)


# 看電影
def movie(func, loop):
    for i in range(loop):
        print('i was listening to music! %s !%s' % (func, ctime()))
        sleep(5)


# 創建線程數組
threads = []
# 創建線程t1，並添加到線程數組
t1 = threading.Thread(target=music, args=('愛情買賣', 2))
threads.append(t1)
# 創建線程t2，並添加到線程數組
t2 = threading.Thread(target=music, args=('一代宗師', 2))
threads.append(t2)

if __name__ == '__main__':
    # 啟動線程
    for t in threads:
        t.start()
    # 守護線程
    for t in threads:
        t.join()

    print('all end:', ctime())

注：import threading: 引入線程模塊

       threads = []:創建線程數組，用於裝載線程。

       threading.Thread(): 通過調用threading模塊的Thread（）方法來創建線程。

運行結果如下：

從上面運行的結果可以看出，兩個子線程（music，movie）同時啟動於10分15秒，知道所有線程結束於10分17秒共好使2秒。從執行的結果可以看出兩個線程達到了並行工作。

優化線程的創建

從上面例子中發現線程的創建很麻煩，每創建一個線程都需要一個t（t1，t2.。。。。）當創建的線程較多時，這樣的操作及其的不方便。

from time import sleep, ctime
import threading


# 創建超級播放器
def super_player(file_, loop):
    for i in range(2):
        print('start playing: %s !%s' % (file_, ctime()))
        sleep(2)
# 播放文件與播放時長
lists = {'愛情買賣.mp3':3,'阿凡達.mp4':5,'傳奇.mp3':4}

threads = []
files = range(len(lists))
print(files)
# 創建線程
print(lists.items())
for file_,time in lists.items():
    t = threading.Thread(target=super_player,args=(file_,time))
    print(t)
    threads.append(t)

if __name__ == '__main__':
    # 啟動線程
    for t in files:
        threads[t].start()
    # 守護線程
    for t in files:
        threads[t].join()

    print(' end:%s'% ctime())

 

from time import sleep, ctime
import threading


# 創建超級播放器
def super_player(file_, loop):
    for i in range(3):  # 控制線程的循環次數
        print('start playing: %s !%s' % (file_, ctime()))
        sleep(3)  # 每次循環的間接次數


# 播放文件與播放時長
lists = {'愛情買賣.mp3': 3, '阿凡達.mp4': 5, '傳奇.mp3': 4}

threads = []
files = range(len(lists))
print(len(lists))

print(files)  # 打印的結果是range（0，3）
# 創建線程
print(lists.items())
for file_, time in lists.items():
    t = threading.Thread(target=super_player, args=(file_, time))
    print(t)
    threads.append(t)

if __name__ == '__main__':
    # 啟動線程
    for t in files:
        threads[t].start()
    # 守護線程
    for t in files:
        threads[t].join()

    print(' end:%s' % ctime())

 創建了一個super_player()函數，這個函數可以接收播放文件和播放時長，可以播放任何文件。

創建了一個lists字典用於存放播放文件名與時長，通過for循環讀取字典，並調用super_play()函數創建字典，接着將創建的字典都追加到threads數組中。

最后通過循環啟動線程數組threads中的線程。

 

創建線程類（未懂）

import threading
from time import sleep, ctime


# 創建線程類
class MyThread (threading.Thread):
    def __init__(self, func, args, name=''):
        threading.Thread.__init__ (self)
        self.func = func
        self.args = args
        self.name = name

    def run(self):
        self.func (*self.args)


# 創建超級播放器
def super_player(file_, loop):
    for i in range (3):  # 控制線程的循環次數
        print ('start playing: %s !%s' % (file_, ctime ()))
        sleep (3)  # 每次循環的間接次數


# 播放文件與播放時長
lists = {'愛情買賣.mp3': 3, '阿凡達.mp4': 5, '傳奇.mp3': 4}

threads = []
files = range (len (lists))
print (len (lists))

print (files)  # 打印的結果是range（0，3）
# 創建線程
print (lists.items ())
for file_, time in lists.items ():
    t = threading.Thread (target=super_player, args=(file_, time))
    print (t)
    threads.append (t)

if __name__ == '__main__':
    # 啟動線程
    for t in files:
        threads[t].start ()
    # 守護線程
    for t in files:
        threads[t].join ()

    print (' end:%s' % ctime ())

MyThread（threading.Thread）

創建MyThread類，用於繼承threading.Thread類

__init__()類的初始化方法對func，args，name等參數進行初始化。

self.func (*self.args)函數的作用是當函數參數已經存在於一個元組或者字典中時，apply（）間接地調用函數。args是一個包含將要提供給函數的按位置傳遞的參數元組。
如果省略了args，則任何參數不會被傳遞，kwargs是一個包含關鍵字參數的字典。



注：以上內容為轉載