一 multiprocessing模組介紹

    python中的多執行緒無法利用多核優勢，如果想要充分地使用多核CPU的資源（os.cpu_count()檢視），在python中大部分情況需要使用多程序。Python提供了multiprocessing。
    multiprocessing模組用來開啟子程序，並在子程序中執行我們定製的任務（比如函式），該模組與多執行緒模組threading的程式設計介面類似。

　 multiprocessing模組的功能眾多：支援子程序、通訊和共享資料、執行不同形式的同步，提供了Process、Queue、Pipe、Lock等元件。

    需要再次強調的一點是：與執行緒不同，程序沒有任何共享狀態，程序修改的資料，改動僅限於該程序內。

二 Process類的介紹

    建立程序的類：

Process([group [, target [, name [, args [, kwargs]]]]])，由該類例項化得到的物件，表示一個子程序中的任務（尚未啟動）

強調：
1. 需要使用關鍵字的方式來指定引數
2. args指定的為傳給target函式的位置引數，是一個元組形式，必須有逗號

    引數介紹：

1 group引數未使用，值始終為None
2 
3 target表示呼叫物件，即子程序要執行的任務
4 
5 args表示呼叫物件的位置引數元組，args=(1,2,'egon',)
6 
7 kwargs表示呼叫物件的字典,kwargs={'name':'egon','age':18}
8 
9 name為子程序的名稱
 

　 方法介紹：

 1 p.start()：啟動程序，並呼叫該子程序中的p.run() 
 2 p.run():程序啟動時執行的方法，正是它去呼叫target指定的函式，我們自定義類的類中一定要實現該方法  
 3 
 4 p.terminate():強制終止程序p，不會進行任何清理操作，如果p建立了子程序，該子程序就成了殭屍程序，使用該方法需要特別小心這種情況。如果p還儲存了一個鎖那麼也將不會被釋放，進而導致死鎖
 5 p.is_alive():如果p仍然執行，返回True
 6 
 7 p.join([timeout]):主執行緒等待p終止（強調：是主執行緒處於等的狀態，而p是處於執行的狀態）。timeout是可選的超時時間，需要強調的是，p.join只能join住start開啟的程序，而不能join住run開啟的程序  
 

 屬性介紹：

1 p.daemon：預設值為False，如果設為True，代表p為後臺執行的守護程序，當p的父程序終止時，p也隨之終止，並且設定為True後，p不能建立自己的新程序，必須在p.start()之前設定
2 
3 p.name:程序的名稱
4 
5 p.pid：程序的pid
6 
7 p.exitcode:程序在執行時為None、如果為–N，表示被訊號N結束(瞭解即可)
8 
9 p.authkey:程序的身份驗證鍵,預設是由os.urandom()隨機生成的32字元的字串。這個鍵的用途是為涉及網路連線的底層程序間通訊提供安全性，這類連線只有在具有相同的身份驗證鍵時才能成功（瞭解即可）

三 Process類的使用

注意：在windows中Process()必須放到# if __name__ == '__main__':下

Since Windows has no fork, the multiprocessing module starts a new Python process and imports the calling module. 
If Process() gets called upon import, then this sets off an infinite succession of new processes (or until your machine runs out of resources). 
This is the reason for hiding calls to Process() inside

if __name__ == "__main__"
since statements inside this if-statement will not get called upon import.
由於Windows沒有fork，多處理模組啟動一個新的Python程序並匯入呼叫模組。 
如果在匯入時呼叫Process（），那麼這將啟動無限繼承的新程序（或直到機器耗盡資源）。 
這是隱藏對Process（）內部呼叫的原，使用if __name__ == “__main __”，這個if語句中的語句將不會在匯入時被呼叫。

詳細解釋

建立並開啟子程序的兩種方式

#開程序的方法一:
import time
import random
from multiprocessing import Process
def piao(name):
    print('%s piaoing' %name)
    time.sleep(random.randrange(1,5))
    print('%s piao end' %name)



p1=Process(target=piao,args=('egon',)) #必須加,號
p2=Process(target=piao,args=('alex',))
p3=Process(target=piao,args=('wupeqi',))
p4=Process(target=piao,args=('yuanhao',))

p1.start()
p2.start()
p3.start()
p4.start()
print('主執行緒')

方法一

#開程序的方法二:
import time
import random
from multiprocessing import Process


class Piao(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print('%s piaoing' %self.name)

        time.sleep(random.randrange(1,5))
        print('%s piao end' %self.name)

p1=Piao('egon')
p2=Piao('alex')
p3=Piao('wupeiqi')
p4=Piao('yuanhao')

p1.start() #start會自動呼叫run
p2.start()
p3.start()
p4.start()
print('主執行緒')

方法二

程序直接的記憶體空間是隔離的

from multiprocessing import Process
n=100 #在windows系統中應該把全域性變數定義在if __name__ == '__main__'之上就可以了
def work():
    global n
    n=0
    print('子程序內: ',n)


if __name__ == '__main__':
    p=Process(target=work)
    p.start()
    print('主程序內: ',n)

View Code

練習1：把上週所學的socket通訊變成併發的形式

from socket import *
from multiprocessing import Process

server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind(('127.0.0.1',8080))
server.listen(5)

def talk(conn,client_addr):
    while True:
        try:
            msg=conn.recv(1024)
            if not msg:break
            conn.send(msg.upper())
        except Exception:
            break

if __name__ == '__main__': #windows下start程序一定要寫到這下面
    while True:
        conn,client_addr=server.accept()
        p=Process(target=talk,args=(conn,client_addr))
        p.start()

server端

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))


while True:
    msg=input('>>: ').strip()
    if not msg:continue

    client.send(msg.encode('utf-8'))
    msg=client.recv(1024)
    print(msg.decode('utf-8'))

多個client端

每來一個客戶端，都在服務端開啟一個程序，如果併發來一個萬個客戶端，要開啟一萬個程序嗎，你自己嘗試著在你自己的機器上開啟一萬個，10萬個程序試一試。
解決方法：程序池

這麼實現有沒有問題？？？

Process物件的join方法

from multiprocessing import Process
import time
import random

class Piao(Process):
    def __init__(self,name):
        self.name=name
        super().__init__()
    def run(self):
        print('%s is piaoing' %self.name)
        time.sleep(random.randrange(1,3))
        print('%s is piao end' %self.name)


p=Piao('egon')
p.start()
p.join(0.0001) #等待p停止,等0.0001秒就不再等了
print('開始')

join：主程序等，等待子程序結束

from multiprocessing import Process
import time
import random
def piao(name):
    print('%s is piaoing' %name)
    time.sleep(random.randint(1,3))
    print('%s is piao end' %name)

p1=Process(target=piao,args=('egon',))
p2=Process(target=piao,args=('alex',))
p3=Process(target=piao,args=('yuanhao',))
p4=Process(target=piao,args=('wupeiqi',))

p1.start()
p2.start()
p3.start()
p4.start()

#有的同學會有疑問:既然join是等待程序結束,那麼我像下面這樣寫,程序不就又變成序列的了嗎?
#當然不是了,必須明確：p.join()是讓誰等？
#很明顯p.join()是讓主執行緒等待p的結束，卡住的是主執行緒而絕非程序p，

#詳細解析如下：
#程序只要start就會在開始運行了,所以p1-p4.start()時,系統中已經有四個併發的程序了
#而我們p1.join()是在等p1結束,沒錯p1只要不結束主執行緒就會一直卡在原地,這也是問題的關鍵
#join是讓主執行緒等,而p1-p4仍然是併發執行的,p1.join的時候,其餘p2,p3,p4仍然在執行,等#p1.join結束,可能p2,p3,p4早已經結束了,這樣p2.join,p3.join.p4.join直接通過檢測，無需等待
# 所以4個join花費的總時間仍然是耗費時間最長的那個程序執行的時間
p1.join()
p2.join()
p3.join()
p4.join()

print('主執行緒')


#上述啟動程序與join程序可以簡寫為
# p_l=[p1,p2,p3,p4]
# 
# for p in p_l:
#     p.start()
# 
# for p in p_l:
#     p.join()

有了join，程式不就是串行了嗎？？？

Process物件的其他方法或屬性（瞭解）

#程序物件的其他方法一:terminate,is_alive
from multiprocessing import Process
import time
import random

class Piao(Process):
    def __init__(self,name):
        self.name=name
        super().__init__()

    def run(self):
        print('%s is piaoing' %self.name)
        time.sleep(random.randrange(1,5))
        print('%s is piao end' %self.name)


p1=Piao('egon1')
p1.start()

p1.terminate()#關閉程序,不會立即關閉,所以is_alive立刻檢視的結果可能還是存活
print(p1.is_alive()) #結果為True

print('開始')
print(p1.is_alive()) #結果為False

terminate與is_alive

from multiprocessing import Process
import time
import random
class Piao(Process):
    def __init__(self,name):
        # self.name=name
        # super().__init__() #Process的__init__方法會執行self.name=Piao-1,
        #                    #所以加到這裡,會覆蓋我們的self.name=name

        #為我們開啟的程序設定名字的做法
        super().__init__()
        self.name=name

    def run(self):
        print('%s is piaoing' %self.name)
        time.sleep(random.randrange(1,3))
        print('%s is piao end' %self.name)

p=Piao('egon')
p.start()
print('開始')
print(p.pid) #檢視pid

name與pid

殭屍程序與孤兒程序（瞭解）

參考部落格：http://www.cnblogs.com/Anker/p/3271773.html

一：殭屍程序（有害）
　　殭屍程序：一個程序使用fork建立子程序，如果子程序退出，而父程序並沒有呼叫wait或waitpid獲取子程序的狀態資訊，那麼子程序的程序描述符仍然儲存在系統中。這種程序稱之為僵死程序。詳解如下

我們知道在unix/linux中，正常情況下子程序是通過父程序建立的，子程序在建立新的程序。子程序的結束和父程序的執行是一個非同步過程,即父程序永遠無法預測子程序到底什麼時候結束，如果子程序一結束就立刻回收其全部資源，那麼在父程序內將無法獲取子程序的狀態資訊。

因此，UNⅨ提供了一種機制可以保證父程序可以在任意時刻獲取子程序結束時的狀態資訊：
1、在每個程序退出的時候，核心釋放該程序所有的資源，包括開啟的檔案，佔用的記憶體等。但是仍然為其保留一定的資訊（包括程序號the process ID，退出狀態the termination status of the process，執行時間the amount of CPU time taken by the process等）
2、直到父程序通過wait / waitpid來取時才釋放. 但這樣就導致了問題，如果程序不呼叫wait / waitpid的話，那麼保留的那段資訊就不會釋放，其程序號就會一直被佔用，但是系統所能使用的程序號是有限的，如果大量的產生僵死程序，將因為沒有可用的程序號而導致系統不能產生新的程序. 此即為殭屍程序的危害，應當避免。

　　任何一個子程序(init除外)在exit()之後，並非馬上就消失掉，而是留下一個稱為殭屍程序(Zombie)的資料結構，等待父程序處理。這是每個子程序在結束時都要經過的階段。如果子程序在exit()之後，父程序沒有來得及處理，這時用ps命令就能看到子程序的狀態是“Z”。如果父程序能及時 處理，可能用ps命令就來不及看到子程序的殭屍狀態，但這並不等於子程序不經過殭屍狀態。  如果父程序在子程序結束之前退出，則子程序將由init接管。init將會以父程序的身份對殭屍狀態的子程序進行處理。

二：孤兒程序（無害）

　　孤兒程序：一個父程序退出，而它的一個或多個子程序還在執行，那麼那些子程序將成為孤兒程序。孤兒程序將被init程序(程序號為1)所收養，並由init程序對它們完成狀態收集工作。

　　孤兒程序是沒有父程序的程序，孤兒程序這個重任就落到了init程序身上，init程序就好像是一個民政局，專門負責處理孤兒程序的善後工作。每當出現一個孤兒程序的時候，核心就把孤 兒程序的父程序設定為init，而init程序會迴圈地wait()它的已經退出的子程序。這樣，當一個孤兒程序淒涼地結束了其生命週期的時候，init程序就會代表黨和政府出面處理它的一切善後工作。因此孤兒程序並不會有什麼危害。

我們來測試一下（建立完子程序後，主程序所在的這個指令碼就退出了，當父程序先於子程序結束時，子程序會被init收養，成為孤兒程序，而非殭屍程序），檔案內容

import os
import sys
import time

pid = os.getpid()
ppid = os.getppid()
print 'im father', 'pid', pid, 'ppid', ppid
pid = os.fork()
#執行pid=os.fork()則會生成一個子程序
#返回值pid有兩種值：
#    如果返回的pid值為0，表示在子程序當中
#    如果返回的pid值>0，表示在父程序當中
if pid > 0:
    print 'father died..'
    sys.exit(0)

# 保證主執行緒退出完畢
time.sleep(1)
print 'im child', os.getpid(), os.getppid()

執行檔案，輸出結果：
im father pid 32515 ppid 32015
father died..
im child 32516 1

看，子程序已經被pid為1的init程序接收了，所以殭屍程序在這種情況下是不存在的，存在只有孤兒程序而已，孤兒程序宣告週期結束自然會被init來銷燬。


三：殭屍程序危害場景：

　　例如有個程序，它定期的產 生一個子程序，這個子程序需要做的事情很少，做完它該做的事情之後就退出了，因此這個子程序的生命週期很短，但是，父程序只管生成新的子程序，至於子程序 退出之後的事情，則一概不聞不問，這樣，系統執行上一段時間之後，系統中就會存在很多的僵死程序，倘若用ps命令檢視的話，就會看到很多狀態為Z的程序。 嚴格地來說，僵死程序並不是問題的根源，罪魁禍首是產生出大量僵死程序的那個父程序。因此，當我們尋求如何消滅系統中大量的僵死程序時，答案就是把產生大 量僵死程序的那個元凶槍斃掉（也就是通過kill傳送SIGTERM或者SIGKILL訊號啦）。槍斃了元凶程序之後，它產生的僵死程序就變成了孤兒進 程，這些孤兒程序會被init程序接管，init程序會wait()這些孤兒程序，釋放它們佔用的系統程序表中的資源，這樣，這些已經僵死的孤兒程序 就能瞑目而去了。

四：測試
#1、產生殭屍程序的程式test.py內容如下

#coding:utf-8
from multiprocessing import Process
import time,os

def run():
    print('子',os.getpid())

if __name__ == '__main__':
    p=Process(target=run)
    p.start()
    
    print('主',os.getpid())
    time.sleep(1000)


#2、在unix或linux系統上執行
[[email protected] ~]# python3  test.py &
[1] 18652
[[email protected]-31-0-19 ~]# 主 18652
子 18653

[[email protected]-31-0-19 ~]# ps aux |grep Z
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root     18653  0.0  0.0      0     0 pts/0    Z    20:02   0:00 [python3] <defunct> #出現殭屍程序
root     18656  0.0  0.0 112648   952 pts/0    S+   20:02   0:00 grep --color=auto Z

[[email protected]-31-0-19 ~]# top #執行top命令發現1zombie
top - 20:03:42 up 31 min,  3 users,  load average: 0.01, 0.06, 0.12
Tasks:  93 total,   2 running,  90 sleeping,   0 stopped,   1 zombie
%Cpu(s):  0.0 us,  0.3 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  1016884 total,    97184 free,    70848 used,   848852 buff/cache
KiB Swap:        0 total,        0 free,        0 used.   782540 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND                                                                                                                                        
root      20   0   29788   1256    988 S  0.3  0.1   0:01.50 elfin                                                                                                                      


#3、
等待父程序正常結束後會呼叫wait／waitpid去回收殭屍程序
但如果父程序是一個死迴圈，永遠不會結束，那麼該殭屍程序就會一直存在，殭屍程序過多，就是有害的
解決方法一：殺死父程序
解決方法二：對開啟的子程序應該記得使用join，join會回收殭屍程序
參考python2原始碼註釋
class Process(object):
    def join(self, timeout=None):
        '''
        Wait until child process terminates
        '''
        assert self._parent_pid == os.getpid(), 'can only join a child process'
        assert self._popen is not None, 'can only join a started process'
        res = self._popen.wait(timeout)
        if res is not None:
            _current_process._children.discard(self)

join方法中呼叫了wait，告訴系統釋放殭屍程序。discard為從自己的children中剔除

解決方法三：http://blog.csdn.net/u010571844/article/details/50419798

View Code

思考：

from multiprocessing import Process
import time,os

def task():
    print('%s is running' %os.getpid())
    time.sleep(3)
    
if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    p.join() # 等待程序p結束後，join函式內部會發送系統呼叫wait，去告訴作業系統回收掉程序p的id號

    print(p.pid) #？？？此時能否看到子程序p的id號
    print('主')

#答案：可以
#分析：
p.join()是像作業系統傳送請求，告知作業系統p的id號不需要再佔用了，回收就可以，
此時在父程序內還可以看到p.pid,但此時的p.pid是一個無意義的id號，因為作業系統已經將該編號回收

打個比方：
我黨相當於作業系統，控制著整個中國的硬體，每個人相當於一個程序，每個人都需要跟我黨申請一個身份證號
該號碼就相當於程序的pid，人死後應該到我黨那裡登出身份證號，p.join()就相當於要求我黨回收身份證號，但p的家人（相當於主程序）
仍然持有p的身份證，但此刻的身份證已經沒有意義

答案 

四 守護程序

主程序建立守護程序

　　其一：守護程序會在主程序程式碼執行結束後就終止

　　其二：守護程序內無法再開啟子程序,否則丟擲異常：AssertionError: daemonic processes are not allowed to have children

注意：程序之間是互相獨立的，主程序程式碼執行結束，守護程序隨即終止

from multiprocessing import Process
import time
import random

class Piao(Process):
    def __init__(self,name):
        self.name=name
        super().__init__()
    def run(self):
        print('%s is piaoing' %self.name)
        time.sleep(random.randrange(1,3))
        print('%s is piao end' %self.name)


p=Piao('egon')
p.daemon=True #一定要在p.start()前設定,設定p為守護程序,禁止p建立子程序,並且父程序程式碼執行結束,p即終止執行
p.start()
print('主')

View Code

#主程序程式碼執行完畢,守護程序就會結束
from multiprocessing import Process
from threading import Thread
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")


p1=Process(target=foo)
p2=Process(target=bar)

p1.daemon=True
p1.start()
p2.start()
print("main-------") #列印該行則主程序程式碼結束,則守護程序p1應該被終止,可能會有p1任務執行的列印資訊123,因為主程序列印main----時,p1也執行了,但是隨即被終止

迷惑人的例子

五 程序同步(鎖)

程序之間資料不共享,但是共享同一套檔案系統,所以訪問同一個檔案,或同一個列印終端,是沒有問題的,

而共享帶來的是競爭，競爭帶來的結果就是錯亂，如何控制，就是加鎖處理

part1：多個程序共享同一列印終端

#併發執行,效率高,但競爭同一列印終端,帶來了列印錯亂
from multiprocessing import Process
import os,time
def work():
    print('%s is running' %os.getpid())
    time.sleep(2)
    print('%s is done' %os.getpid())

if __name__ == '__main__':
    for i in range(3):
        p=Process(target=work)
        p.start()

併發執行,效率高,但競爭同一列印終端,帶來了列印錯亂

#由併發變成了序列,犧牲了執行效率,但避免了競爭
from multiprocessing import Process,Lock
import os,time
def work(lock):
    lock.acquire()
    print('%s is running' %os.getpid())
    time.sleep(2)
    print('%s is done' %os.getpid())
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    for i in range(3):
        p=Process(target=work,args=(lock,))
        p.start()

加鎖：由併發變成了序列,犧牲了執行效率,但避免了競爭

part2：多個程序共享同一檔案

檔案當資料庫，模擬搶票

#檔案db的內容為：{"count":1}
#注意一定要用雙引號，不然json無法識別
from multiprocessing import Process,Lock
import time,json,random
def search():
    dic=json.load(open('db.txt'))
    print('\033[43m剩餘票數%s\033[0m' %dic['count'])

def get():
    dic=json.load(open('db.txt'))
    time.sleep(0.1) #模擬讀資料的網路延遲
    if dic['count'] >0:
        dic['count']-=1
        time.sleep(0.2) #模擬寫資料的網路延遲
        json.dump(dic,open('db.txt','w
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Python學習【第21篇】：程序池以及回撥函式 python併發程式設計之多程序2-------------資料共享及程序池和回撥函式
     
  
  
   
   
    python併發程式設計之多程序2-------------資料共享及程序池和回撥函式
    
   
  
 
 
  
   
    
     
      
      一、資料共享 
      1.程序間的通訊應該儘量避免共享資料的方式 
      2.程序 

  
 

    

    
    
Python學習【第20篇】：互斥鎖以及程序之間的三種通訊方式（IPC）以及生產者個消費者模型 python併發程式設計之多程序1-----------互斥鎖與程序間的通訊
     
  
  
   
   
    python併發程式設計之多程序1-----------互斥鎖與程序間的通訊
    
   
  
 
 
  
   
    
     
      
      一、互斥鎖 
      程序之間資料隔離，但是共享一套檔案系統，因而可以通過檔案來實現程序直接的通訊， 

  
 

    

    
    
python併發程式設計之多程序、多執行緒、非同步和協程
     
 
                

一、多執行緒

　　多執行緒就是允許一個程序記憶體在多個控制權，以便讓多個函式同時處於啟用狀態，從而讓多個函式的操作同時執行。即使是單CPU的計算機，也可以通過不停地在不同執行緒的指令間切換，從而造成多執行緒同時執行的效果。

　　多執行緒相當於一個併發(concunrr 

  
 

    

    
    
python併發程式設計之多程序理論部分
     
 一 什麼是程序
    程序：正在進行的一個過程或者說一個任務。而負責執行任務則是cpu。
    舉例（單核+多道，實現多個程序的併發執行）：
    egon在一個時間段內有很多工要做：python備課的任務，寫書的任務，交女朋友的任務，王者榮耀上分的任務，　　
    但egon同一時刻只能做一 

  
 

    

    
    
python併發程式設計之多程序
     
 一 multiprocessing模組介紹
    python中的多執行緒無法利用多核優勢，如果想要充分地使用多核CPU的資源（os.cpu_count()檢視），在python中大部分情況需要使用多程序。Python提供了multiprocessing。    multiprocessing模組用來開啟 

  
 

    

    
    
Python併發程式設計之多執行緒使用
     
 目錄 
 
  
  一 開啟執行緒的兩種方式 
  二 在一個程序下開啟多個執行緒與在一個程序下開啟多個子程序的區別 
  三 練習 
  四 執行緒相關的其他方法 
  五 守護執行緒  
  六 Python GIL(Global Interpreter Lock) 
  七 同步鎖 
  八 死鎖現象 

  
 

    

    
    
Python學習【第24篇】：死鎖，遞迴鎖，訊號量，Event事件，執行緒Queue python併發程式設計之多執行緒2------------死鎖與遞迴鎖，訊號量等
     
  
  
   
   
    python併發程式設計之多執行緒2------------死鎖與遞迴鎖，訊號量等
    
   
  
 
 
  
   
    
     
      
      一、死鎖現象與遞迴鎖 
      程序也是有死鎖的 
      所謂死鎖： 是指兩個或兩個以上 

  
 

    

    
    
Python學習【第23篇】：利用threading模組開執行緒 python併發程式設計之多執行緒1
     
  
  
   
   
    python併發程式設計之多執行緒1
    
   
  
 
 
  
   
    
     
      
      一多執行緒的概念介紹 
      threading模組介紹 
      threading模組和multiprocessing模組在使用層 

  
 

    

    
    
併發程式設計之多程序
     
 一、什麼是程序
 一個正在執行的程式稱之為程序        是一種抽象概念 表示一個執行某件事情的過程，程序的概念 起源於作業系統
    第一代計算機  程式是固定 無法修改 某種計算機只能幹某種活
第二代批處理系統 需要人工參與  將程式攢成一批 統一執行，序列執行 提高計算機的的利用率  但是除錯麻煩 

  
 

    

    
    
python併發程式設計之多執行緒理論部分
     
 一 什麼是執行緒　　
　　在傳統作業系統中，每個程序有一個地址空間，而且預設就有一個控制執行緒
　　執行緒顧名思義，就是一條流水線工作的過程，一條流水線必須屬於一個車間，一個車間的工作過程是一個程序
      車間負責把資源整合到一起，是一個資源單位，而一個車間內至少有一個流水線
      流水線 

  
 

    

    
    
41、併發程式設計之多程序實操篇
     
 ### 一 multiprocessing模組介紹

python中的多執行緒無法利用多核優勢，如果想要充分地使用多核CPU的資源（os.cpu_count()檢視），在Python中大部分情況需要使用多程序。Python提供了multiprocessing。 multiprocessing模組用來開啟子程序 

  
 

    

    
    
Python併發程式設計之執行緒池/程序池
     
  
 
 Python併發程式設計之執行緒池/程序池 
 2017/01/18 · 基礎知識 · 2 評論 · 併發, 執行緒池, 程序池 
 原文出處： ZiWenXie    
 引言 
 Pyt 

  
 

    

    
    
linux網路程式設計之多程序併發伺服器
     
 
                1）使用多程序併發伺服器考慮的因素：

      （1）父程序描述最大檔案描述符的個數（父程序需要關閉accept返回的新檔案描述符）

      （2）系統內可建立程序的個數（與記憶體大小相關）

      （3）程序建立過多是否降低整體服務效能

2）多程序建立併發 

  
 

    

    
    
Python併發程式設計之建立多執行緒的幾種方法
     
 
                今天的內容會比較基礎，主要是為了讓新手也能無障礙地閱讀，所以還是要再鞏固下基礎。學完了基礎，你們也就能很順暢地跟著我的思路理解以後的文章。本文目錄學會使用函式建立多執行緒學會使用類建立多執行緒多執行緒：必學函式講解經過總結，Python建立多執行緒主要有如下兩種方法：函式類接 

  
 

    

    
    
python多工程式設計之多程序程式設計
     
 
							
							
							多工程式設計：

意義：充分利用計算機資源，同時執行多個任務，提高程式 
        整體的執行效率 
定義：通過程式利用計算機的多個核心 達到同時執行多個任務的目的 
        以此達到提升程式執行效率的目的 
實施方案：多程序程式設計  多執行緒程 

  
 

    

    
    
併發程式設計之多執行緒執行緒安全
     
 

 
 

 
什麼是執行緒安全？ 
為什麼有執行緒安全問題？ 
當多個執行緒同時共享，同一個全域性變數或靜態變數，做寫的操作時，可能會發生資料衝突問題，也就是執行緒安全問題。但是做讀操作是不會發生資料衝突問題。 
案例: 需求現在有100張火車票，有兩個視窗同時搶火車票，請使用多執行緒模擬搶票效果。 
p 

  
 

    

    
    
併發程式設計之多執行緒基礎
     
 

 
 

 
執行緒與程序區別 
每個正在系統上執行的程式都是一個程序。每個程序包含一到多個執行緒。執行緒是一組指令的集合，或者是程式的特殊段，它可以在程式裡獨立執行。也可以把它理解為程式碼執行的上下文。所以執行緒基本上是輕量級的程序，它負責在單個程式裡執行多工。通常由作業系統負責多個執行緒的排程和執行。 

  
 

    

    
    
Python併發程式設計之同步\非同步and阻塞\非阻塞
     
 一、什麼是程序 
程序： 正在進行的一個過程或者說一個任務。而負責執行任務則是cpu。 
程序和程式的區別： 程式僅僅只是一堆程式碼而已，而程序指的是程式的執行過程。 
需要強調的是：同一個程式執行兩次，那也是兩個程序，比如開啟暴風影音，雖然都是同一個軟體，但是一個可以播郭德綱，一個可以播高曉鬆。 
二、並行 

  
 

    

    
    
15.python併發程式設計(執行緒--程序--協程)
     
 一.程序：1.定義：程序最小的資源單位，本質就是一個程式在一個數據集上的一次動態執行(執行)的過程2.組成：程序一般由程式，資料集，程序控制三部分組成:(1)程式：用來描述程序要完成哪些功能以及如何完成(2)資料集：是程式在執行過程中所需要使用的一切資源(3)程序控制塊：用來記錄程序外部特徵，描述程序的執行變 

  
 

    

    
    
Python併發程式設計之常用概念剖析
     
  
 
 1 引言 
 　　併發、並行、序列、同步、非同步、阻塞、非阻塞、程序、執行緒、協程是併發程式設計中的常見概念，相似卻也有卻不盡相同，令人頭痛，這一篇博文中我們來區分一下這些概念。 
 2 併發與並行 
 　　在解釋併發與並行之前，我們必須先明確：單個處理器（一個單核CPU）在某一個時刻只能處理一個執