並行程式執行緒二

和程序不同的是，程序中使用佇列用於程序間通訊：from multiprocessing import queue

執行緒中使用佇列：from queue import queue（python3中）;

from queue import queue（python2中）

不過，程序和執行緒中關於queue的所有操作都是一樣的，即put，get，qsize，full，empty等。

# encoding=utf-8
import threading
import time
#python2中
#from queue import queue
#python3中
from queue import queue
class
producer
(threading.thread)
:def
run(self)
:global queue
count =
0while
true
:if queue.qsize(
)<
1000
:for i in
range
(100):
count = count +
1 msg =
'生成產品'
+str
(count)
queue.put(msg)
print
(msg)
time.sleep(
0.5)
class
consumer
(threading.thread)
:def
run(self)
:global queue
while
true
:if queue.qsize(
)>
100:
for i in
range(3
):msg = self.name +
'消費了 '
+queue.get(
)print
(msg)
time.sleep(1)
if __name__ ==
'__main__'
: queue = queue(
)for i in
range
(500):
queue.put(
'初始產品'
+str
(i))
# 兩個生產者
for i in
range(2
):p = producer(
) p.start(
)# 五個消費者
for i in
range(5
):c = consumer(
) c.start(
)

# coding=utf-8
import threading
# 建立全域性threadlocal物件:
local_school = threading.local(
)def
process_student()
:# 獲取當前執行緒關聯的student:
std = local_school.student
print
('hello, %s (in %s)'
%(std, threading.current_thread(
).name)
)def
process_thread
(name)
:# 繫結threadlocal的student:
local_school.student = name
process_student(
)t1 = threading.thread(target= process_thread, args=
('dongge',)
, name=
'thread-a'
)t2 = threading.thread(target= process_thread, args=
('老王',)
, name=
'thread-b'
)t1.start(
)t2.start(
)

同步：你喊你朋友吃飯，你朋友在忙，你就⼀直在那等，等你

朋友忙完了，你們⼀起去。

非同步：你喊你朋友吃飯，你朋友在忙，便告訴你：你先去忙，等我這邊結束了去找你。

非同步的好處是，當使用多程序時，主程序不需要一直等待子程序結束，可以先去做自己的事情，當子程序結束的時候作業系統會告訴主程序，子程序已結束，然後主程序會停下手中的任務轉而去做作業系統安排的任務。

# coding=utf-8
from multiprocessing import pool
import time
import os
deftest()
:print
("---程序池中的程序---pid=%d,ppid=%d--"
%(os.getpid(
),os.getppid())
)for i in
range(3
):print
("----%d---"
%i) time.sleep(1)
return
"hahah"
deftest2
(args)
:print
("---callback func--pid=%d"
%os.getpid())
print
("---callback func--args=%s"
%args)
if __name__==
"__main__"
: pool = pool(3)
#非同步的理解：主程序正在做某件事情，突然　來了一件更需要立刻去做的事情，
#那麼這種，在父程序去做某件事情的時候　並不知道是什麼時候去做，的模式　就稱為非同步
while
true
: time.sleep(1)
print
("----主程序-pid=%d----"
%os.getpid())
# ---程序池中的程序---pid=14912,ppid=14776--
# ----0---
# ----主程序-pid=14776----
# ----1---
# ----主程序-pid=14776----
# ----2---
# ----主程序-pid=14776----
# ---callback func--pid=14776
# ---callback func--args=hahah
# ----主程序-pid=14776----
# ----主程序-pid=14776----
# ----主程序-pid=14776----
# ----主程序-pid=14776----

gil，全域性直譯器鎖，作用是限制多執行緒同時執行，保證同一時間內只有乙個執行緒在執行。那為什麼要這麼做呢？因為對於多執行緒而言，全域性變數是共享的，為了執行緒的安全，需要保證同一時刻只有乙個執行緒在工作，因此在單核或多核處理器中，多執行緒並不能並行，只是併發而已，不能提高效率，反而多執行緒執行乙個程式所用時間可能比單執行緒還要多，因為作業系統不斷排程各個執行緒浪費了時間。

那我們說的多執行緒提高效率指的是什麼？多執行緒提高效率，不如說是提高了cpu的執行時間，即減少了等待時間。

併發，指的是乙個處理器同時處理多個任務，並行指的是多個處理器同時處理多個任務，就好比乙個人同時吃三個饅頭和三個人吃三個饅頭，併發的時間肯定是並行的三倍。

那麼解決多執行緒效率的方案有哪些？

在需要並行的地方用c語言寫

能用程序就不用執行緒

將cpython直譯器換jpython，因為 gil只有cpython直譯器。

並行程式執行緒二

併發程式與並行程式

Java並行程式基礎

Java 並行程式基礎

並行程式 執行緒 二

併發程式與並行程式

Java並行程式基礎

Java 並行程式基礎

相關推薦

並行程式執行緒二