38 併發程式設計

一、多道技術

1.1、必備知識點

併發：看起來像同時執行的就可以稱之為併發

並行：真正意義上的同時執行

注：並行肯定算，

單核的計算機肯定不能實現並行，但是可以實現併發！！！

補充：我們直接假設單核就是乙個核，幹活的就乙個人，不要考慮cpu裡面的核心數

1.2、多道技術

節省多個程式執行的總耗時

1.2.1、空間上的復用

多個程式使用一台計算機

1.2.2、時間上的復用

一邊執行程式一邊寫**

1.2.3、切換與儲存

cpu切換分為兩種：

1.當乙個程式遇到io操作的時候，作業系統會剝奪該程式的cpu執行許可權

作用：提高cpu的利用率，也不影響程式的執行效率

2.當乙個程式長時間占用cpu的時候，作業系統也會剝奪該程式的cpu執行許可權

弊端：降低了程式的執行效率

二、程序理論

2.1、程序與程式的區別

程式是已經編寫好的**，還未執行

程序是正在執行的程式

2.2、程序排程

2.2.1、先來先服務排程演算法

先到的先執行，執行完畢後，進入下乙個作業，對長作業有利，對短作業無益

2.2.2、短作業優先演算法

最短的作業優先進行作業，執行完畢後，進入下乙個作業

2.2.3、時間片輪轉法+多級反饋佇列

三、程式執行的三種狀態

四、同步與非同步

同步：任務提交之後，原地等待任務，等待過程中不做任何事

程式層面上的表現是卡住了

非同步：任務提交之後，不會原地等待任務，直接處理其他事情

需要非同步**機制返回任務，之後執行

五、阻塞與非阻塞

阻塞：阻塞態

非阻塞：就緒態，執行態

最高效的組合就是非同步非阻塞

六、開啟**程序的兩種方式

建立乙個啟動項，啟動項為主程序

第一種是：根據函式建立，啟動項需要給函式傳參，之後使用start啟動

第二種是：根據類建立，啟動類，之後使用start啟動

注：建立程序就是在記憶體中申請一塊記憶體空間將需要執行的**丟進去

乙個程序對應在記憶體中就是一塊獨立的記憶體空間

多個程序對應在記憶體中就是多塊獨立的記憶體空間

程序與程序之間資料預設情況下是無法直接互動,如果想互動可以借助於第三方工具、模組

from multiprocessing import

process
import
time
deftask(name):
print('
%s is running
'%name)
time.sleep(3)
print('
%s is over
'%name)
if__name__ == '
__main__':
#1 建立乙個物件
p = process(target=task, args=('
jason
',))
#容器型別哪怕裡面只有1個元素 建議要用逗號隔開
#2 開啟程序
p.start()  #
告訴作業系統幫你建立乙個程序  非同步
print('主'
)    
#第二種方式 類的繼承
from multiprocessing import
process
import
time
class
myprocess(process):
defrun(self):
print('
hello bf girl')
time.sleep(1)
print('
get out!')
if__name__ == '
__main__':
p =myprocess()
p.start()
print('
主')

join就是讓主程序等待子程序**執行完之後，再繼續執行，不影響其他子程序的執行

from multiprocessing import

process
import
time
deftask(name, n):
print('
%s is running
'%name)
time.sleep(n)
print('
%s is over
'%name)
if__name__ == '
__main__':
#p1 = process(target=task, args=('jason', 1))
#p2 = process(target=task, args=('egon', 2))
#p3 = process(target=task, args=('tank', 3))
#start_time = time.time()
#p1.start()
#p2.start()
#p3.start()  # 僅僅是告訴作業系統要建立程序
## time.sleep(50000000000000000000)
## p.join()  # 主程序等待子程序p執行結束之後再繼續往後執行
#p1.join()
#p2.join()
#p3.join()
start_time =time.time()
p_list =
for i in range(1, 4):
p = process(target=task, args=('
子程序%s
'%i, i))
p.start()
for p in
p_list:
p.join()
print('
主', time.time() - start_time)

每個程序都有各自的命名空間，不會影響對方

from multiprocessing import

process
money = 100
deftask():
global money  #
區域性修改全域性
money = 666
print('子'
,money)
if__name__ == '
__main__':
p = process(target=task)
p.start()
p.join()
print(money)

day38 併發程式設計 理論

目錄 三 程序理論 四 開啟程序的兩種方式 參考部落格即可 總結 補充 我們直接假設單核就是乙個核，幹活的就乙個人，不要考慮cpu裡面的核心數 時間上的復用 切換 cpu 分為兩種情況 1.當乙個程式遇到io操作的時候，作業系統會剝奪該程式的cpu執行許可權 作用 提高了cpu的利用率 並且也不影響...

每日程式設計（38）

題目描述 給定整數陣列 a，每次 move 操作將會選擇任意 a i 並將其遞增 1。返回使 a 中的每個值都是唯一的最少操作次數。示例 1 輸入 1,2,2 輸出 1 解釋 經過一次 move 操作，陣列將變為 1,2,3 示例 2 0 a.length 40000 0 a i 40000 分析 ...

併發程式設計學習 併發程式設計的挑戰

死鎖 資源限制的挑戰 併發程式設計的目的是為了讓程式執行的更快，但是並不是啟動更多的執行緒，就能讓程式最大限度的併發執行。在進行併發程式設計時，如果希望通過多執行緒執行任務讓程式執行的更快，會面臨非常多的挑戰，比如上下文切換的問題，死鎖的問題，以及受限於硬體和軟體的資源限制問題 即使是單核處理器也支...