import time
from threading import Thread
#多執行緒併發，是不是看著和多程序很類似
def func(n):
    time.sleep(1)
    print(n)

#併發效果，1秒打印出了所有的數字
for i in range(10):
    t = Thread(target=func,args=(i,))
    t.start()

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('太白',))
    t.start()
    print('主執行緒')

方式1

import time
from threading import Thread
class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)


if __name__ == '__main__':
    t = Sayhi('太白')
    t.start()
    print('主執行緒')

方式2

from threading import Thread
from multiprocessing import Process
import os

def work():
    print('hello',os.getpid())

if __name__ == '__main__':
    #part1:在主程序下開啟多個執行緒,每個執行緒都跟主程序的pid一樣
    t1=Thread(target=work)
    t2=Thread(target=work)
    t1.start()
    t2.start()
    print('主執行緒/主程序pid',os.getpid())

    #part2:開多個程序,每個程序都有不同的pid
    p1=Process(target=work)
    p2=Process(target=work)
    p1.start()
    p2.start()
    print('主執行緒/主程序pid',os.getpid())


pid（程序id）

from threading import Thread
from multiprocessing import Process
import os
import time
def work():
    print('hello')

if __name__ == '__main__':
    s1 = time.time()
    #在主程序下開啟執行緒
    t=Thread(target=work)
    t.start()
    t.join()
    t1 = time.time() - s1
    print('程序的執行時間：',t1)
    print('主執行緒/主程序')
    '''
    列印結果:
    hello
    程序的執行時間： 0.0
    主執行緒/主程序
    '''

    s2 = time.time()
    #在主程序下開啟子程序
    t=Process(target=work)
    t.start()
    t.join()
    t2 = time.time() - s2
    print('執行緒的執行時間：', t2)
    print('主執行緒/主程序')
    '''
    列印結果:
    hello
    執行緒的執行時間： 0.5216977596282959
    主執行緒/主程序
    '''

程序與執行緒開啟效率比較

from  threading import Thread
from multiprocessing import Process
import os
def work():
    global n  #修改全域性變數的值
    n=0

if __name__ == '__main__':
    # n=100
    # p=Process(target=work)
    # p.start()
    # p.join()
    # print('主',n) #毫無疑問子程序p已經將自己的全域性的n改成了0,但改的僅僅是它自己的,檢視父程序的n仍然為100


    n=1
    t=Thread(target=work)
    t.start()
    t.join()   #必須加join，因為主執行緒和子執行緒不一定誰快，一般都是主執行緒快一些，所有我們要等子執行緒執行完畢才能看出效果
    print('主',n) #檢視結果為0,因為同一程序內的執行緒之間共享程序內的資料
# 通過一個global就實現了全域性變數的使用，不需要程序的IPC通訊方法

記憶體資料共享

import multiprocessing
import threading

import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('127.0.0.1',8080))
s.listen(5)

def action(conn):
    while True:
        data=conn.recv(1024)
        print(data)
        msg = input('服務端輸入:') #在多執行緒裡面可以使用input輸入內容，那麼就可以實現客戶端和服務端的聊天了，多程序不能輸入
        conn.send(bytes(msg,encoding='utf-8'))

if __name__ == '__main__':

    while True:
        conn,addr=s.accept()
        p=threading.Thread(target=action,args=(conn,))
        p.start()

tcp_server.py

mport socket

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

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

    s.send(msg.encode('utf-8'))
    data=s.recv(1024)
    print(data)

tcp_client.py

Thread例項物件的方法
  # isAlive(): 返回執行緒是否活動的。
  # getName(): 返回執行緒名。
  # setName(): 設定執行緒名。

threading模組提供的一些方法：
  # threading.currentThread(): 返回當前的執行緒變數。
  # threading.enumerate(): 返回一個包含正在執行的執行緒的list。正在執行指執行緒啟動後、結束前，不包括啟動前和終止後的執行緒。
  # threading.activeCount(): 返回正在執行的執行緒數量，與len(threading.enumerate())有相同的結果

其他方法

from threading import Thread
import threading
from multiprocessing import Process
import os

def work():
    import time
    time.sleep(3)
    print(threading.current_thread().getName())

if __name__ == '__main__':
    #在主程序下開啟執行緒
    t=Thread(target=work)
    t.start()

    print(threading.current_thread())#主執行緒物件
    print(threading.current_thread().getName()) #主執行緒名稱
    print(threading.current_thread().ident) #主執行緒ID
    print(threading.get_ident()) #主執行緒ID
    print(threading.enumerate()) #連同主執行緒在內有兩個執行的執行緒
    print(threading.active_count())
    print('主執行緒/主程序')

    '''
    列印結果:
    <_MainThread(MainThread, started 14104)>
    MainThread
    14104
    [<_MainThread(MainThread, started 14104)>, <Thread(Thread-1, started 17976)>]
    主執行緒/主程序
    Thread-1
    '''

程式碼示例

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('太白',))
    t2=Thread(target=sayhi,args=('alex',))
    t.start()
    t2.start()
    t.join()  #因為這個執行緒用了join方法，主執行緒等待子執行緒的執行結束

    print('主執行緒')
    print(t.is_alive())  #所以t這個執行緒肯定是執行結束了，結果為False
    print(t2.is_alive()) #有可能是True，有可能是False，看子執行緒和主執行緒誰執行的快
    '''
    egon say hello
    主執行緒
    False
    '''

join方法

#1.對主程序來說，執行完畢指的是主程序程式碼執行完畢
#2.對主執行緒來說，執行完畢指的是主執行緒所在的程序內所有非守護執行緒統統執行完畢，主執行緒才算執行完畢

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('taibai',))
    t.setDaemon(True) #必須在t.start()之前設定
    t.start()

    print('主執行緒')
    print(t.is_alive())
    '''
    主執行緒
    True
    '''

守護執行緒示例1

from threading import Thread
from multiprocessing import Process
import time
def func1():
    while True:
        print(666)
        time.sleep(0.5)
def func2():
    print('hello')
    time.sleep(3)

if __name__ == '__main__':
    # t = Thread(target=func1,)
    # t.daemon = True  #主執行緒結束，守護執行緒隨之結束
    # # t.setDaemon(True) #兩種方式，和上面設定守護執行緒是一樣的
    # t.start()
    # t2 = Thread(target=func2,) #這個子執行緒要執行3秒，主執行緒的程式碼雖然執行完了，但是一直等著子執行緒的任務執行完畢，主執行緒才算完畢，因為通過結果你會發現我主執行緒雖然程式碼執行完畢了，\
    # 但是主執行緒的的守護執行緒t1還在執行，說明什麼，說明我的主執行緒還沒有完畢，只不過是程式碼執行完了，一直等著子執行緒t2執行完畢，我主執行緒的守護執行緒才停止，說明子執行緒執行完畢之後，我的主執行緒才執行完畢
    # t2.start()
    # print('主執行緒程式碼執行完啦！')
    p = Process(target=func1,)
    p.daemon = True
    p.start()

    p2 = Process(target=func2,)
    p2.start()
    time.sleep(1) #讓主程序等1秒，為了能看到func1的列印效果
    print('主程序程式碼執行完啦！') #通過結果你會發現，如果主程序的程式碼執行完畢了，那麼主程序就結束了，因為主程序的守護程序p隨著主程序的程式碼結束而結束了，守護程序被回收了，這和執行緒是不一樣的，主執行緒的程式碼完了並不代表主執行緒執行完畢了，需要等著所有其他的非守護的子執行緒執行完畢才算完畢

守護執行緒示例2

三個需要注意的點：
#1.執行緒搶的是GIL鎖，GIL鎖相當於執行許可權，拿到執行許可權後才能拿到互斥鎖Lock，其他執行緒也可以搶到GIL，但如果發現Lock仍然沒有被釋放則阻塞，即便是拿到執行許可權GIL也要立刻交出來

#2.join是等待所有，即整體序列，而鎖只是鎖住修改共享資料的部分，即部分序列，要想保證資料安全的根本原理在於讓併發變成序列，join與互斥鎖都可以實現，毫無疑問，互斥鎖的部分序列效率要更高

#3. 一定要看本小節最後的GIL與互斥鎖的經典分析

GIL VS Lock

    機智的同學可能會問到這個問題，就是既然你之前說過了，Python已經有一個GIL來保證同一時間只能有一個執行緒來執行了，為什麼這裡還需要lock? 

　首先我們需要達成共識：鎖的目的是為了保護共享的資料，同一時間只能有一個執行緒來修改共享的資料

    然後，我們可以得出結論：保護不同的資料就應該加不同的鎖。

　最後，問題就很明朗了，GIL 與Lock是兩把鎖，保護的資料不一樣，前者是直譯器級別的（當然保護的就是直譯器級別的資料，比如垃圾回收的資料），後者是保護使用者自己開發的應用程式的資料，很明顯GIL不負責這件事，只能使用者自定義加鎖處理，即Lock

過程分析：所有執行緒搶的是GIL鎖，或者說所有執行緒搶的是執行許可權

　　執行緒1搶到GIL鎖，拿到執行許可權，開始執行，然後加了一把Lock，還沒有執行完畢，即執行緒1還未釋放Lock，有可能執行緒2搶到GIL鎖，開始執行，執行過程中發現Lock還沒有被執行緒1釋放，於是執行緒2進入阻塞，被奪走執行許可權，有可能執行緒1拿到GIL，然後正常執行到釋放Lock。。。這就導致了序列執行的效果

　　既然是序列，那我們執行

　　t1.start()

　　t1.join

　　t2.start()

　　t2.join()

　　這也是序列執行啊，為何還要加Lock呢，需知join是等待t1所有的程式碼執行完，相當於鎖住了t1的所有程式碼，而Lock只是鎖住一部分操作共享資料的程式碼。

因為Python直譯器幫你自動定期進行記憶體回收，你可以理解為python直譯器裡有一個獨立的執行緒，每過一段時間它起wake up做一次全域性輪詢看看哪些記憶體資料是可以被清空的，此時你自己的程式 裡的執行緒和 py直譯器自己的執行緒是併發執行的，假設你的執行緒刪除了一個變數，py直譯器的垃圾回收執行緒在清空這個變數的過程中的clearing時刻，可能一個其它執行緒正好又重新給這個還沒來及得清空的記憶體空間賦值了，結果就有可能新賦值的資料被刪除了，為了解決類似的問題，python直譯器簡單粗暴的加了鎖，即當一個執行緒執行時，其它人都不能動，這樣就解決了上述的問題，  這可以說是Python早期版本的遺留問題。

from threading import Thread,Lock
import os,time
def work():
    global n
    # lock.acquire() #加鎖
    temp=n
    time.sleep(0.1) #一會將下面迴圈的資料加大並且這裡的時間改的更小試試
    n=temp-1
    # time.sleep(0.02)
    # n = n - 1
    '''如果這樣寫的話看不出來效果，因為這樣寫就相當於直接將n的指向改了，就好比從10，經過1次減1之後，n就直接指向了9，速度太快，看不出效果，那麼我們怎麼辦呢，找一箇中間變數來接收n，然後對這個中間變數進行修改，然後再賦值給n，多一個給n賦值的過程，那麼在這個過程中間，我們加上一點阻塞時間，來看效果，就像讀檔案修改資料之後再寫回檔案的過程。那麼這個程式就會出現結果為9的情況，首先一個程序的全域性變數對於所有執行緒是共享的，由於我們在程式給中間變數賦值，然後給n再次賦值的過程中我們加了一些I/O時間，遇到I/O就切換，那麼每個執行緒都拿到了10，並對10減1了，然後大家都得到了9，然後再賦值給n，所有n等於了9'''
    # lock.release()
if __name__ == '__main__':
    lock=Lock()
    n=100
    l=[]
    # for i in range(10000):  #如果這裡變成了10000，你在執行一下看看結果
    for i in range(100):  #如果這裡變成了10000，你在執行一下看看結果
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #結果肯定為0，由原來的併發執行變成序列，犧牲了執行效率保證了資料安全

需要仔細研究的示例

import threading

R=threading.Lock()

R.acquire() #
#R.acquire()如果這裡還有一個acquire，你會發現，程式就阻塞在這裡了，因為上面的鎖已經被拿到了並且還沒有釋放的情況下，再去拿就阻塞住了
'''
對公共資料的操作
'''
R.release()

from threading import Thread,Lock
import os,time
def work():
    global n
    lock.acquire() #加鎖
    temp=n
    time.sleep(0.1)
    n=temp-1
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #結果肯定為0，由原來的併發執行變成序列，犧牲了執行效率保證了資料安全

同步鎖的引用

分析：
    #1.100個執行緒去搶GIL鎖，即搶執行許可權
    #2. 肯定有一個執行緒先搶到GIL（暫且稱為執行緒1），然後開始執行，一旦執行就會拿到lock.acquire()
    #3. 極有可能執行緒1還未執行完畢，就有另外一個執行緒2搶到GIL，然後開始執行，但執行緒2發現互斥鎖lock還未被執行緒1釋放，於是阻塞，被迫交出執行許可權，即釋放GIL
    #4.直到執行緒1重新搶到GIL，開始從上次暫停的位置繼續執行，直到正常釋放互斥鎖lock，然後其他的執行緒再重複2 3 4的過程 

#不加鎖:併發執行,速度快,資料不安全
from threading import current_thread,Thread,Lock
import os,time
def task():
    global n
    print('%s is running' %current_thread().getName())
    temp=n
    time.sleep(0.5)
    n=temp-1


if __name__ == '__main__':
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()

    stop_time=time.time()
    print('主:%s n:%s' %(stop_time-start_time,n))

'''
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:0.5216062068939209 n:99
'''


#不加鎖:未加鎖部分併發執行,加鎖部分序列執行,速度慢,資料安全
from threading import current_thread,Thread,Lock
import os,time
def task():
    #未加鎖的程式碼併發執行
    time.sleep(3)
    print('%s start to run' %current_thread().getName())
    global n
    #加鎖的程式碼序列執行
    lock.acquire()
    temp=n
    time.sleep(0.5)
    n=temp-1
    lock.release()

if __name__ == '__main__':
    n=100
    lock=Lock()
    threads=[]
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    stop_time=time.time()
    print('主:%s n:%s' %(stop_time-start_time,n))

'''
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:53.294203758239746 n:0
'''

#有的同學可能有疑問:既然加鎖會讓執行變成序列,那麼我在start之後立即使用join,就不用加鎖了啊,也是序列的效果啊
#沒錯:在start之後立刻使用jion,肯定會將100個任務的執行變成序列,毫無疑問,最終n的結果也肯定是0,是安全的,但問題是
#start後立即join:任務內的所有程式碼都是序列執行的,而加鎖,只是加鎖的部分即修改共享資料的部分是序列的
#單從保證資料安全方面,二者都可以實現,但很明顯是加鎖的效率更高.
from threading import current_thread,Thread,Lock
import os,time
def task():
    time.sleep(3)
    print('%s start to run' %current_thread().getName())
    global n
    temp=n
    time.sleep(0.5)
    n=temp-1


if __name__ == '__main__':
    n=100
    lock=Lock()
    start_time=time.time()
    for i in range(100):
        t=Thread(target=task)
        t.start()
        t.join()
    stop_time=time.time()
    print('主:%s n:%s' %(stop_time-start_time,n))

'''
Thread-1 start to run
Thread-2 start to run
......
Thread-100 start to run
主:350.6937336921692 n:0 #耗時是多麼的恐怖
'''

互斥鎖與join的區別（重點）

from threading import Lock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print(123)
mutexA.release()
mutexA.release()

from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print('\033[41m%s 拿到A鎖>>>\033[0m' %self.name)
        mutexB.acquire()
        print('\033[42m%s 拿到B鎖>>>\033[0m' %self.name)
        mutexB.release()
        mutexA.release()

    def func2(self):
        mutexB.acquire()  
        print('\033[43m%s 拿到B鎖???\033[0m' %self.name)
        time.sleep(2)
        #分析：當執行緒1執行完func1，然後執行到這裡的時候，拿到了B鎖，執行緒2執行func1的時候拿到了A鎖，那麼執行緒2還要繼續執行func1裡面的程式碼，再去拿B鎖的時候，發現B鎖被人拿了，那麼就一直等著別人把B鎖釋放，那麼就一直等著，等到執行緒1的sleep時間用完之後，執行緒1繼續執行func2，需要拿A鎖了，但是A鎖被執行緒2拿著呢，還沒有釋放，因為他在等著B鎖被釋放，那麼這倆人就尷尬了，你拿著我的老A，我拿著你的B，這就尷尬了，倆人就停在了原地

        mutexA.acquire()
        print('\033[44m%s 拿到A鎖???\033[0m' %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

'''
Thread-1 拿到A鎖>>>
Thread-1 拿到B鎖>>>
Thread-1 拿到B鎖???
Thread-2 拿到A鎖>>>
然後就卡住，死鎖了
'''

更難一些的死鎖現象

from threading import RLock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print(123)
mutexA.release()
mutexA.release()

import time
from threading import Thread,Lock
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
    noodle_lock.acquire()
    print('%s 搶到了麵條'%name)
    fork_lock.acquire()
    print('%s 搶到了叉子'%name)
    print('%s 吃麵'%name)
    fork_lock.release()
    noodle_lock.release()

def eat2(name):
    fork_lock.acquire()
    print('%s 搶到了叉子' % name)
    time.sleep(1)
    noodle_lock.acquire()
    print('%s 搶到了麵條' % name)
    print('%s 吃麵' % name)
    noodle_lock.release()
    fork_lock.release()

for name in ['taibai','egon','wulaoban']:
    t1 = Thread(target=eat1,args=(name,))
    t2 = Thread(target=eat2,args=(name,))
    t1.start()
    t2.start()

和上面更難一些的死鎖現象是一樣的

import time
from threading import Thread,RLock
fork_lock = noodle_lock = RLock()
def eat1(name)