線程和進(jìn)程

1、線程共享創(chuàng)建它的進(jìn)程的地址空間,進(jìn)程有自己的地址空間

2胆剧、線程可以訪問進(jìn)程所有的數(shù)據(jù)絮姆，線程可以相互訪問

3、線程之間的數(shù)據(jù)是獨(dú)立的

4秩霍、子進(jìn)程復(fù)制線程的數(shù)據(jù)

5篙悯、子進(jìn)程啟動(dòng)后是獨(dú)立的 ，父進(jìn)程只能殺掉子進(jìn)程铃绒，而不能進(jìn)行數(shù)據(jù)交換

6鸽照、修改線程中的數(shù)據(jù)，都是會(huì)影響其他的線程颠悬，而對(duì)于進(jìn)程的更改矮燎，不會(huì)影響子進(jìn)程

threading.Thread

Thread 是threading模塊中最重要的類之一，可以使用它來創(chuàng)建線程赔癌。有兩種方式來創(chuàng)建線程：一種是通過繼承Thread類漏峰，重寫它的run方法；另一種是創(chuàng)建一個(gè)threading.Thread對(duì)象届榄，在它的初始化函數(shù)（init）中將可調(diào)用對(duì)象作為參數(shù)傳入浅乔。

先來看看通過繼承threading.Thread類來創(chuàng)建線程的例子：

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, arg):
        # super(MyThread, self).__init__() # 新式類繼承原有方法寫法
        threading.Thread.__init__(self)
        self.arg = arg

    def run(self):
        time.sleep(2)
        print(self.arg)

for i in range(10):
    thread = MyThread(i)
    print(thread.name)
    thread.start()

另外一種創(chuàng)建線程的方法：

import threading
import time

def process(arg):
    time.sleep(2)
    print(arg)

for i in range(10):
    t = threading.Thread(target=process, args=(i,))
    print(t.name)
    t.start()

Thread類還定義了以下常用方法與屬性：

Thread.getName() 獲取線程名稱
Thread.setName() 設(shè)置線程名稱
Thread.name 線程名稱

Thread.ident 獲取線程的標(biāo)識(shí)符。線程標(biāo)識(shí)符是一個(gè)非零整數(shù)，只有在調(diào)用了start()方法之后該屬性才有效靖苇，否則它只返回None

判斷線程是否是激活的（alive）席噩。從調(diào)用start()方法啟動(dòng)線程，到run()方法執(zhí)行完畢或遇到未處理異常而中斷 這段時(shí)間內(nèi)贤壁，線程是激活的

Thread.is_alive()
Thread.isAlive()

Thread.join([timeout]) 調(diào)用Thread.join將會(huì)使主調(diào)線程堵塞悼枢，直到被調(diào)用線程運(yùn)行結(jié)束或超時(shí)。參數(shù)timeout是一個(gè)數(shù)值類型脾拆，表示超時(shí)時(shí)間馒索，如果未提供該參數(shù)，那么主調(diào)線程將一直堵塞到被調(diào)線程結(jié)束

Python GIL(Global Interpreter Lock)

GIL并不是Python的特性名船，它是在實(shí)現(xiàn)Python解析器(CPython)時(shí)所引入的一個(gè)概念绰上。就好比C++是一套語言（語法）標(biāo)準(zhǔn)，但是可以用不同的編譯器來編譯成可執(zhí)行代碼渠驼。有名的編譯器例如GCC蜈块，INTEL C++，Visual C++等迷扇。Python也一樣百揭，同樣一段代碼可以通過CPython，PyPy蜓席，Psyco等不同的Python執(zhí)行環(huán)境來執(zhí)行器一。像其中的JPython就沒有GIL。然而因?yàn)镃Python是大部分環(huán)境下默認(rèn)的Python執(zhí)行環(huán)境厨内。所以在很多人的概念里CPython就是Python盹舞，也就想當(dāng)然的把GIL歸結(jié)為Python語言的缺陷。所以這里要先明確一點(diǎn)：GIL并不是Python的特性隘庄，Python完全可以不依賴于GIL踢步。

線程鎖的使用：

# 鎖：GIL 全局解釋器 它是為了保證線程在運(yùn)行過程中不被搶占
number = 0
lock = threading.RLock()    # 創(chuàng)建鎖


def run(num):
    lock.acquire()  # 加鎖
    global number
    number += 1
    print(number)
    time.sleep(2)
    lock.release()  # 釋放鎖

for i in range(10):
    t = threading.Thread(target=run, args=(i, ))
    t.start()

Join & Daemon
主線程A中，創(chuàng)建了子線程B丑掺，并且在主線程A中調(diào)用了B.setDaemon(),這個(gè)的意思是获印，把主線程A設(shè)置為守護(hù)線程，這時(shí)候街州，要是主線程A執(zhí)行結(jié)束了兼丰，就不管子線程B是否完成,一并和主線程A退出.這就是setDaemon方法的含義，這基本和join是相反的唆缴。此外鳍征，還有個(gè)要特別注意的：必須在start() 方法調(diào)用之前設(shè)置，如果不設(shè)置為守護(hù)線程面徽，程序會(huì)被無限掛起艳丛。

class MyThread1(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        print("thread start")
        time.sleep(3)
        print('thread end')

print('main start')
thread1 = MyThread1()
# thread1.setDaemon(True)     # 設(shè)置子線程是否跟隨主線程一起結(jié)束
thread1.start()
time.sleep(1)
print('satrt join')
# thread1.join()    # 使主線程阻塞匣掸，直至子線程運(yùn)行完畢再繼續(xù)主線程
print('end join')

def run(n):
    print('[%s]------running----\n' % n)
    time.sleep(2)
    print('--done--')


def main():
    for i in range(5):
        t = threading.Thread(target=run, args=[i,])
        t.start()
        # t.join()
        print('starting thread', t.getName())


m = threading.Thread(target=main,args=[])
# m.setDaemon(True)  # 將主線程設(shè)置為Daemon線程,它退出時(shí),其它子線程會(huì)同時(shí)退出,不管是否執(zhí)行完任務(wù)
m.start()
# m.join()    # 使主線程阻塞，直至子線程運(yùn)行完畢再繼續(xù)主線程
print("---main thread done----")

線程鎖(互斥鎖Mutex)
一個(gè)進(jìn)程下可以啟動(dòng)多個(gè)線程氮双，多個(gè)線程共享父進(jìn)程的內(nèi)存空間碰酝，也就意味著每個(gè)線程可以訪問同一份數(shù)據(jù)，此時(shí)戴差，如果2個(gè)線程同時(shí)要修改同一份數(shù)據(jù)送爸，會(huì)出現(xiàn)什么狀況？

num = 100  # 設(shè)定一個(gè)共享變量

def subNum():
    global num # 在每個(gè)線程中都獲取這個(gè)全局變量
    print('--get num:', num)
    time.sleep(2)
    num -= 1 # 對(duì)此公共變量進(jìn)行-1操作

thread_list = []
for i in range(100):
    t = threading.Thread(target=subNum)
    t.start()
    thread_list.append(t)

for t in thread_list: # 等待所有線程執(zhí)行完畢
    t.join()

print('final num:', num)

# 加鎖版本

def subNum():
    global num  # 在每個(gè)線程中都獲取這個(gè)全局變量
    print('--get num:', num)
    time.sleep(1)
    lock.acquire()  # 修改數(shù)據(jù)前加鎖
    num -= 1  # 對(duì)此公共變量進(jìn)行-1操作
    lock.release()  # 修改后釋放


num = 100  # 設(shè)定一個(gè)共享變量
thread_list = []
lock = threading.Lock()  # 生成全局鎖
for i in range(100):
    t = threading.Thread(target=subNum)
    t.start()
    thread_list.append(t)

for t in thread_list:  # 等待所有線程執(zhí)行完畢
    t.join()

print('final num:', num)

Rlock與Lock的區(qū)別：
RLock允許在同一線程中被多次acquire暖释。而Lock卻不允許這種情況袭厂。否則會(huì)出現(xiàn)死循環(huán)，程序不知道解哪一把鎖球匕。注意：如果使用RLock纹磺，那么acquire和release必須成對(duì)出現(xiàn)，即調(diào)用了n次acquire谐丢，必須調(diào)用n次的release才能真正釋放所占用的鎖
<br />
Events

Python提供了Event對(duì)象用于線程間通信，它是由線程設(shè)置的信號(hào)標(biāo)志蚓让，如果信號(hào)標(biāo)志位真乾忱，則其他線程等待直到信號(hào)接觸。

Event對(duì)象實(shí)現(xiàn)了簡(jiǎn)單的線程通信機(jī)制历极，它提供了設(shè)置信號(hào)窄瘟，清除信號(hào)，等待等用于實(shí)現(xiàn)線程間的通信趟卸。

event = threading.Event() 創(chuàng)建一個(gè)event

1 設(shè)置信號(hào)
event.set()

使用Event的set（）方法可以設(shè)置Event對(duì)象內(nèi)部的信號(hào)標(biāo)志為真蹄葱。Event對(duì)象提供了isSet（）方法來判斷其內(nèi)部信號(hào)標(biāo)志的狀態(tài)。
當(dāng)使用event對(duì)象的set（）方法后锄列，isSet（）方法返回真

2 清除信號(hào)
event.clear()

使用Event對(duì)象的clear（）方法可以清除Event對(duì)象內(nèi)部的信號(hào)標(biāo)志图云，即將其設(shè)為假，當(dāng)使用Event的clear方法后邻邮，isSet()方法返回假

3 等待
event.wait()

Event對(duì)象wait的方法只有在內(nèi)部信號(hào)為真的時(shí)候才會(huì)很快的執(zhí)行并完成返回竣况。當(dāng)Event對(duì)象的內(nèi)部信號(hào)標(biāo)志位假時(shí)，
則wait方法一直等待到其為真時(shí)才返回筒严。也就是說必須set新號(hào)標(biāo)志位真

def do(event):
    print('start')
    event.wait()
    print('execute')

event_obj = threading.Event()
for i in range(10):
    t = threading.Thread(target=do, args=(event_obj,))
    t.start()

event_obj.clear()
inp = input('輸入內(nèi)容:')
if inp == 'true':
    event_obj.set()