Python控制多進程與多線程併發數

Python控制多進程與多線程併發數

0x01    前言

    原本寫了腳本用於暴力破解密碼，但是1秒鐘嘗試一個密碼2220000個密碼個人天，想用多線程但是隻會一個for全開，難道開2220000個線程嗎？只好學習控制線程數了，官方文檔很差看，以爲結構不夠清晰，網上找不少文章也都不很清晰，只有for全開線程，沒有控制線程數的具體說明，最終終於根據多篇文章和官方文檔算是搞明白基礎的多線程怎麼實現法了，怕長時間不用又忘記，找着麻煩就貼這了，跟我同樣新手也能夠參照參照。

    先說進程和線程的區別：
            (1)地址空間:進程內的一個執行單元;進程至少有一個線程;它們共享進程的地址空間;而進程有本身獨立的地址空間;
            (2)資源擁有:進程是資源分配和擁有的單位,同一個進程內的線程共享進程的資源
            (3)線程是處理器調度的基本單位,但進程不是.
            (4)兩者都可併發執行.

    不能理解的話簡單打比方就是一個進程就像一個程序同樣，併發互不干擾。一個進程靠一個或多個線程執行處理，併發的線程是cpu在不停的來回切換執行，固然是快到你感受不出的。

    拿上面我遇到的困難來講吧，大量的數據須要執行相同的處理，一個操做中間可能會有一些等待時間，一個一個執行浪費大量時間，那麼就同時執行吧，咱們能夠用兩種並行辦法：

    進程並行或者線程並行

    各有優缺點，要看狀況，不是絕對的，在此不討論這個，這引出下面兩種Python並行處理方法（註釋感受很清晰詳細了，再也不多說）

    忘記說了，看留言纔想起來，這裏貼出了兩種方法是爲了理解兩種的區別和相同點，可是討論的是python，python是又全局解釋器鎖(GIL)，他會將進程中的線程序列化，也就多核cpu實際上並不能達到並行提升速度的目的，而使用多進程則是不受限的，因此實際應用中都是推薦多進程的，也就是第一種，簡單又高效，下面多線程能夠做爲對比(參考文章)

0x02    進程處理方法

#coding:utf-8
import random
from time import sleep
import sys
import multiprocessing
import os
#
#需求分析：有大批量數據須要執行，並且是重複一個函數操做（例如爆破密碼），若是所有開始線程數N多，這裏控制住線程數m個並行執行，其餘等待
#
lock=multiprocessing.Lock()#一個鎖
def a(x):#模擬須要重複執行的函數
    lock.acquire()#輸出時候上鎖，不然進程同時輸出時候會混亂，不可讀
    print '開始進程：',os.getpid(),'模擬進程時間:',x
    lock.release()
    
    sleep(x)#模擬執行操做
    
    lock.acquire()
    print '結束進程：',os.getpid(),'預測下一個進程啓動會使用該進程號'
    lock.release()
list=[]
for i in range(10):#產生一個隨機數數組，模擬每次調用函數須要的輸入，這裏模擬總共有10組須要處理
    list.append(random.randint(1,10))
    
pool=multiprocessing.Pool(processes=3)#限制並行進程數爲3
pool.map(a,list)#建立進程池，調用函數a，傳入參數爲list,此參數必須是一個可迭代對象,由於map是在迭代建立每一個進程

輸出：

0x03    線程處理方法：

#coding:utf-8
import threading
import random
import Queue
from time import sleep
import sys
#
#需求分析：有大批量數據須要執行，並且是重複一個函數操做（例如爆破密碼），若是所有開始線程數N多，這裏控制住線程數m個並行執行，其餘等待
#
#繼承一個Thread類，在run方法中進行須要重複的單個函數操做
class Test(threading.Thread):
    def __init__(self,queue,lock,num):
        #傳遞一個隊列queue和線程鎖，並行數
        threading.Thread.__init__(self)
        self.queue=queue
        self.lock=lock
        self.num=num
    def run(self):
        #while True:#不使用threading.Semaphore，直接開始全部線程，程序執行完畢線程都還不死，最後的print threading.enumerate()能夠看出
        with self.num:#同時並行指定的線程數量，執行完畢一個則死掉一個線程
            #如下爲須要重複的單次函數操做
            n=self.queue.get()#等待隊列進入
            lock.acquire()#鎖住線程，防止同時輸出形成混亂
            print '開始一個線程：',self.name,'模擬的執行時間：',n
            print '隊列剩餘：',queue.qsize()
            print threading.enumerate()
            lock.release()
            sleep(n)#執行單次操做，這裏sleep模擬執行過程
            self.queue.task_done()#發出此隊列完成信號
threads=[]
queue=Queue.Queue()
lock=threading.Lock()
num=threading.Semaphore(3)#設置同時執行的線程數爲3，其餘等待執行
#啓動全部線程
for i in range(10):#總共須要執行的次數
    t=Test(queue,lock,num)
    t.start()
    threads.append(t)
    #吧隊列傳入線程，是run結束等待開始執行，放下面單獨一個for也行，這裏少個循環吧
    n=random.randint(1,10)
    queue.put(n)#模擬執行函數的逐個不一樣輸入
#吧隊列傳入線程，是run結束等待開始執行
#for t in threads:
#    n=random.randint(1,10)
#    queue.put(n)
#等待線程執行完畢
for t in threads:
    t.join()
queue.join()#等待隊列執行完畢才繼續執行，不然下面語句會在線程未接受就開始執行
print '全部執行完畢'
print threading.active_count()
print threading.enumerate()

輸出：

其實我也仍是有些納悶的，我在python 2.7上用多線程開死循環簡單看下cpu確實多核在交替進行啊