什麼是行程(process)?什麼是執行緒？

基礎：

什麼是進程(process)?

每一個程式的記憶體是獨立的，例如：world不能存取QQ。 

程式：QQ是以一個整體的形式暴露給作業系統管理，裡麵包含了各種資源的呼叫(記憶體管理、網路介面呼叫等)。啟動一個QQ，也就是啟動了一個行程。

什麼是執行緒(thread)?

執行緒是作業系統能夠進行運算調度的最小單位。 執行緒包含在流程之中，是進程中的實際運作單位。

一個行程中最少有一個執行緒。

一個執行緒時指 行程中一個單一順序的控制流。

一個進程中科院並發多個線程，每個線程並行執行不同的任務，線程與線程之間是相互獨立的。

執行緒與行程的差異：

行程：對各種資源管理的集合

#執行緒：作業系統最小的調度單位，是一串指令的集合

關係：

進程中第一個線程時主線程，主線程創建其他線程，其他線程也可以創建線程，線程之間是平等的；

進程有父進程、子進程，獨立的記憶體空間，唯一的進程標識符，pid;

什麼是上下文切換？

上下文切換，也稱為做行程切換或任務切換，是指cpu從一個行程或執行緒切換到另一個行程或執行緒。舉例說明，如下：

a.開啟QQ和微信，先聊QQ，然後切換到微信進行聊天，再切換到QQ，這個操作就叫做上下文切換。

b.同時開啟多個應用，電腦cpu配置是4核，多個應用之間進行切換時，沒有卡頓現像也完全感受不到cpu在進行任務切換，因為cpu處理很快，所以應用程式之間切換沒有卡頓現象；

 

單執行緒：

import timeimport requestsdef get_res():
    urls = ['','','','']
    start = time.time()for url in urls:print(url)
        resp = requests.get(url)print(resp)
    end = time.time()print('单线程运行时间:', end - start)

執行結果：

##

http://www.baidu.com<Response [200]>https://www.taobao.com/
<Response [200]>https://www.jd.com/
<Response [200]>http://www.meilishuo.com/
<Response [200]>单线程运行时间: 1.0470597743988037

解釋：

a. cpu順序被要求

b.除非cpu從一個url取得的回應，否則不會去請求下一個url

# c. 網路請求會花費較長的時間，所以cpu在等待網路請求的返回時間內一直處於閒置狀態

# 多執行緒：

import timeimport threadingdef run(count):#每次执行该方法，需要休息2stime.sleep(2)print(count)#开始创建多线程start = time.time()for i in range(5):#创建线程，指定运行哪个函数，也就是指定哪个函数运行需要创建多线程#target=要运行的函数名# args=函数运行传入的参数，run方法需要传入count，把创建th = threading.Thread(target=run, args=(i, ))#启动线程    th.start()#多线程创建完毕且运行结束end = time.time()print('运行时间：', end - start)

運行結果：

运行时间： 0.0
104
2
3

解釋：

a. 列印出來的運行時間統計的不是多執行緒的運行時間，因為沒有執行run都要等待2s，所以多執行緒的運行時間至少為2s，

那麼列印的結果是什麼？

　　列印的運行時間是主線程的運行時間，因為在運行python檔案時，如果不啟動多線程，至少有一個線程在運行

#　　線程與線程之間是相互獨立的，最開始運行的是主線程，當運行到threading.Thread時，創建一個線程，創建的線程執行循環方，主線程執行其他操作

#　　主執行緒不等待其他執行緒結束後再結束

b. 列印的count資料是無序的，因為多執行緒執行run方法，並不是第一個請求結束後才進行下一個請求的，而是創建一個線程後執行run方法，接著創建另一個線程，哪個線程執行完畢就會打印出結果

c.總共創建了5個執行緒

 

若想統計多執行緒總共的執行時間，也就是從開始創建執行緒到執行緒結束運行之間的時間(不需要考慮執行緒之間怎麼運行的)，操作如下：

join()等待（等待執行緒結束）

import timeimport threadingdef run(count):#每次执行该方法，需要休息2stime.sleep(2)print(count)#开始创建多线程start = time.time()#存放创建的所有线程threads_list = []for i in range(5):#创建线程，指定运行哪个函数，也就是指定哪个函数运行需要创建多线程#target=要运行的函数名# args=函数运行传入的参数，run方法需要传入count，把创建th = threading.Thread(target=run, args=(i, ))#启动线程    th.start()#把启动的每一个线程添加到线程组内    threads_list.append(th)for t in threads_list:#主线程循环等待每个子线程运行完毕， t代表每个子线程t.join()  #等待线程结束#多线程创建完毕且运行结束end = time.time()print('运行时间：', end - start)

執行結果：

01
2
4
3运行时间： 2.0011146068573

 守護線程

守護線程：主線程運行結束後，不管守護線程執行是否結束，都會結束，舉例說明：

例如皇帝有很多僕人，當皇帝死了之後，那麼多僕人就得陪葬。

只要非守護線程結束了，不管守護線程結束沒結束，程式都結束

import threadingimport timedef run(count):
    time.sleep(2)print(count)for i in range(5):#循环创建线程，总共5个线程t = threading.Thread(target=run, args=(i, ))#设置守护线程,新创建的这些线程都是 主线程的 守护线程， 主线程创建一个线程后 就运行结束了    t.setDaemon(True)#启动线程，守护线程设置必须在start前面    t.start()print('over')

GIL 全局解释器锁

例如 4核机器上 
Python创建4线程，四个线程均匀分到多核上，但是同时只能一核在处理数据。 
python调用操作系统、C语音的原生接口，在出口做了设置。全局解释器锁，保证数据统一 
所以有人说python的线程是假线程。 
在修改数据的时候，为了防止数据改乱了，所以多线程就变成串行处理，但是以为是python在处理，实际上是调用了操作系统的C语音的线程接口，所以中间的过程，python控制不了了，只知道结果。在这种情况下，设置的方式是出口控制，虽然四个线程，但是同一时间只有一个线程在工作。 
　 
所以这算是python的一个缺陷，但是也不能说是python的缺陷，是Cpython的缺陷。因为Cpython是C语音写的，以后python的未来是PYPY。 

线程锁

线程锁，又叫互斥锁

线程之间沟通：保证同一时间只有一个线程修改数据

python2.x 中需要加锁，Python3.x中加不加锁都一样，因为解释器做了优化

import threadingfrom threading import Lock#创建lock对象num = 0
lock = Lock()   #申请一把锁,创建锁的对象def run2():global num
    lock.acquire()      #修改数据前 加锁num += 1lock.release()      #修改后释放解锁lis = []for i in range(5):#创建线程t = threading.Thread(target=run2)#启动线程    t.start()#将启动的线程添加到线程组内    lis.append(t)for t in lis:#等待线程运行结束    t.join()#num的值为5，执行多次后，会出现不一样的值print('over', num)

RLock 递归锁

大锁中还有小锁、递归锁，解锁时就混了，所以用递归锁，Rlock()

import threading,timedef run1():print("grab the first part data")
    lock.acquire()global num
    num +=1lock.release()return numdef run2():print("grab the second part data")
    lock.acquire()global  num2
    num2+=1lock.release()return num2def run3():
    lock.acquire()
    res = run1()print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()print(res,res2)if __name__ == '__main__':

    num,num2 = 0,0
    lock = threading.RLock()  # 声明递归锁# lock = threading.Lock() # 用互斥锁，会锁死了，弄混锁情况，可以试一下for i in range(10):
        t = threading.Thread(target=run3)
        t.start()while threading.active_count() != 1:print(threading.active_count())else:print('----all threads done---')print(num,num2)

 多线程的另一种写法：

import threadingimport timeclass MyThread(threading.Thread):def __init__(self, num):
        threading.Thread.__init__(self)
        self.num = numdef run(self):  # 定义每个线程要运行的函数print("running on number:%s" % self.num)
        time.sleep(3)if __name__ == '__main__':
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()

多进程(了解即可)：

python里面的多线程，是不能利用多核cpu的，如果想利用多核cpu的话，就得使用多进程

多进程适用CPU密集型任务

多线程适用io密集型任务

from multiprocessing import Processdef f(name):
    time.sleep(2)print('hello', name)if __name__ == '__main__':for i in range(10):
        p = Process(target=f, args=('niu',))
        p.start()

以上是什麼是行程(process)?什麼是執行緒？的詳細內容。更多資訊請關注PHP中文網其他相關文章！