# 程序/執行緒/協程
# IO:同步/非同步/阻塞/非阻塞
#  greenlet gevent
# 事件驅動與非同步IO
# Select\Poll\Epoll非同步IO 以及selectors模組
# Python佇列/RabbitMQ佇列　　
##############################################################################################
1.什麼是程序?程序和程式之間有什麼區別?
   程序:一個程式的執行例項稱為程序;
   每個程序都提供執行程式所需的資源。
   程序有一個虛擬地址空間、可執行程式碼、對系統物件的開放控制代碼、一個安全上下文、一個惟一的程序識別符號、環境變數、一個優先順序類、最小和最大工作集大小，以及至少一個執行執行緒
 
;
   每個程序都由一個執行緒啟動，這個執行緒通常被稱為主執行緒，但是可以從它的任何執行緒中建立額外的執行緒;
   程式並不能單獨執行，只有將程式裝載到記憶體中，系統為它分配資源才能執行，而這種執行的程式就稱之為程序;
   程式和程序的區別就在於：程式是指令的集合，它是程序執行的靜態描述文字；程序是程式的一次執行活動，屬於動態概念。
   在多道程式設計中，我們允許多個程式同時載入到記憶體中，在作業系統的排程下，可以實現併發地執行，大大提高了CPU的利用率
2.什麼是執行緒?
   程序的缺點有:
      程序只能在一個時間幹一件事，如果想同時幹兩件事或多件事，程序就無能為力了。
      程序在執行的過程中如果阻塞，例如等待輸入，整個程序就會掛起，即使程序中有些工作不依賴於輸入的資料，也將無法執行。
 
   執行緒是作業系統能夠進行運算排程的最小單位。
   它被包含在程序之中，是程序中的實際運作單位。
   一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以併發多個執行緒，每條執行緒並行執行不同的任務
   執行緒是一個執行上下文，它是一個CPU用來執行指令流的所有資訊。
3.程序和執行緒之間的關係?
   執行緒共享建立它的程序的地址空間;程序有自己的地址空間。(記憶體地址)
   執行緒可以直接訪問其程序的資料段;程序有自己的父程序資料段的副本。
   執行緒可以直接與程序的其他執行緒通訊;程序必須使用程序間通訊來與兄弟程序通訊。
   新執行緒很容易建立;新程序需要複製父程序。
 
   執行緒可以對同一程序的執行緒進行相當大的控制;程序只能對子程序執行控制。
   對主執行緒的更改(取消、優先順序更改等)可能會影響流程的其他執行緒的行為;對父程序的更改不會影響子程序。
4.python GIL全域性直譯器鎖
   無論你啟多少個執行緒，你有多少個cpu, Python在執行的時候會淡定的在同一時刻只允許一個執行緒執行
http: // www.dabeaz.com / python / UnderstandingGIL.pdf
5.Python threading模組的使用
   基本呼叫方式1
      import threading
      import time


      def sayhi(num):  # 定義每個執行緒要執行的函式
print("running on number:%s" % num)

         time.sleep(3)


      if __name__ == '__main__':
         t1 = threading.Thread(target=sayhi, args=(1,))  # 生成一個執行緒例項
t2 = threading.Thread(target=sayhi, args=(2,))  # 生成另一個執行緒例項
t1.start()  # 啟動執行緒
t2.start()  # 啟動另一個執行緒
print(t1.getName())  # 獲取執行緒名
print(t2.getName())
   基本呼叫方式2
      import threading
      import time


      class MyThread(threading.Thread):
         def __init__(self, num):
            threading.Thread.__init__(self)
            self.num = num

         def 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()
6.守護執行緒Daemon:
   非守護程序執行緒退出，就可以將守護執行緒殺死。
# _*_coding:utf-8_*_
import time
   import threading


   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(1)
         print('starting thread', t.getName())


   m = threading.Thread(target=main, args=[])
   m.setDaemon(True)  # 將main執行緒設定為Daemon執行緒,它做為程式主執行緒的守護執行緒,當主執行緒退出時,m執行緒也會退出,由m啟動的其它子執行緒會同時退出,不管是否執行完任務
m.start()
   m.join(timeout=2)
   print("---main thread done----")
7.執行緒鎖(互斥鎖)
   一個程序下可以啟動多個執行緒，多個執行緒共享父程序的記憶體空間，也就意味著每個執行緒可以訪問同一份資料，此時，如果2個執行緒同時要修改同一份資料，可能會導致資料被同時修改而使得計算結果不準確(重複賦值)
   import time
   import threading


   def addNum():
      global num  # 在每個執行緒中都獲取這個全域性變數
print('--get num:', num)
      time.sleep(1)
      num -= 1  # 對此公共變數進行-1操作
num = 100  # 設定一個共享變數
thread_list = []
   for i in range(100):
      t = threading.Thread(target=addNum)
      t.start()
      thread_list.append(t)

   for t in thread_list:  # 等待所有執行緒執行完畢
t.join()

   print('final num:', num)
   加上執行緒鎖
import time
   import threading


   def addNum():
      global num  # 在每個執行緒中都獲取這個全域性變數
print('--get num:', num)
      time.sleep(1)
      lock.acquire()  # 修改資料前加鎖
num -= 1  # 對此公共變數進行-1操作
lock.release()  # 修改後釋放
num = 100  # 設定一個共享變數
thread_list = []
   lock = threading.Lock()  # 生成全域性鎖
for i in range(100):
      t = threading.Thread(target=addNum)
      t.start()
      thread_list.append(t)

   for t in thread_list:  # 等待所有執行緒執行完畢
t.join()

   print('final num:', num)
8.執行緒鎖與GIL之間的關係?
   加入GIL主要的原因是為了降低程式的開發的複雜度，
   比如現在的你寫python不需要關心記憶體回收的問題，因為Python直譯器幫你自動定期進行記憶體回收，你可以理解為python直譯器裡有一個獨立的執行緒，
   每過一段時間它起wake up做一次全域性輪詢看看哪些記憶體資料是可以被清空的，此時你自己的程式裡的執行緒和 py直譯器自己的執行緒是併發執行的，
   假設你的執行緒刪除了一個變數，py直譯器的垃圾回收執行緒在清空這個變數的過程中的clearing時刻，
   可能一個其它執行緒正好又重新給這個還沒來及得清空的記憶體空間賦值了，結果就有可能新賦值的資料被刪除了，
   為了解決類似的問題，python直譯器簡單粗暴的加了鎖，即當一個執行緒執行時，其它人都不能動
9.遞迴鎖(Rlock 不用遞迴鎖而多重加lock鎖會導致被鎖住,程式卡死)
   import threading, time


   def run1():
      print("grab the first part data")
      lock.acquire()
      global num
      num += 1
lock.release()
      return num


   def run2():
      print("grab the second part data")
      lock.acquire()
      global num2
      num2 += 1
lock.release()
      return num2


   def 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() #注意遞迴鎖是Rlock
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)
10.Semaphore(訊號量):
   同時允許一定數量的執行緒更改資料
import threading, time

   def run(n):
      semaphore.acquire()
      time.sleep(1)
      print("run the thread: %s\n" % n)
      semaphore.release()

   if __name__ == '__main__':

      num = 0
semaphore = threading.BoundedSemaphore(5)  # 最多允許5個執行緒同時執行
for i in range(20):
         t = threading.Thread(target=run, args=(i,))
         t.start()

   while threading.active_count() != 1:
      pass  # print threading.active_count()
else:
      print('----all threads done---')
      print(num)
11.Events事件:通過Event來實現兩個或多個執行緒間的互動
event = threading.Event()
   # a client thread can wait for the flag to be set
event.wait()
   # a server thread can set or reset it
event.set()
   event.clear()
   一個紅綠燈的例子，即起動一個執行緒做交通指揮燈，生成幾個執行緒做車輛，車輛行駛按紅燈停，綠燈行的規則:
   import threading,time
   import random
   def light():
       if not event.isSet():
           event.set() #wait就不阻塞 #綠燈狀態
count = 0
while True:
           if count < 10:
               print('\033[42;1m--green light on---\033[0m')
           elif count <13:
               print('\033[43;1m--yellow light on---\033[0m')
           elif count <20:
               if event.isSet():
                   event.clear()
               print('\033[41;1m--red light on---\033[0m')
           else:
               count = 0
event.set() #開啟綠燈
time.sleep(1)
           count +=1
def car(n):
       while 1:
           time.sleep(random.randrange(10))
           if  event.isSet(): #綠燈
print("car [%s] is running.." % n)
           else:
               print("car [%s] is waiting for the red light.." %n)
   if __name__ == '__main__':
       event = threading.Event()
       Light = threading.Thread(target=light)
       Light.start()
       for i in range(3):
           t = threading.Thread(target=car,args=(i,))
           t.start()
12.python queue佇列(執行緒佇列)
   class queue.Queue(maxsize=0) #先入先出
class queue.LifoQueue(maxsize=0) #last in fisrt out
class queue.PriorityQueue(maxsize=0) #儲存資料時可設定優先順序的佇列
Queue.qsize()
   Queue.empty() #return True if empty
Queue.full() # return True if full
Queue.put(item, block=True, timeout=None) #將專案放入佇列中。如果可選的args塊是true，則超時為None(預設值)，如果需要則阻塞，直到空閒槽可用。如果超時是一個正數，它會在大多數超時秒中阻塞，如果在那個時間內沒有空閒槽，則會引發完全的異常。否則(塊是false)，如果一個空閒槽立即可用，則在佇列上放置一個項，否則就會丟擲完全異常(在這種情況下會忽略超時)。
Queue.put_nowait(item) #Equivalent to put(item, False).
Queue.get(block=True, timeout=None) #從佇列中刪除並返回一個專案。如果可選的args塊是true，則超時為None(預設值)，如果需要則阻塞，直到有可用的項。如果超時是一個正數，它會在大多數超時秒中阻塞，如果在那個時間內沒有可用的項，則會丟擲空的異常。否則(塊是false)，如果立即可用，返回一個專案，否則將丟擲空異常(在這種情況下忽略超時)。
Queue.get_nowait() #Equivalent to get(False).
兩種方法來支援跟蹤佇列的任務是否已經被守護程序的消費者執行緒完全地處理。
Queue.task_done()
   Queue.join() block直到queue被消費完畢
13.生產者消費者模型
   生產者消費者模式是通過一個容器來解決生產者和消費者的強耦合問題。
   生產者和消費者彼此之間不直接通訊，而通過阻塞佇列來進行通訊，
   所以生產者生產完資料之後不用等待消費者處理，直接扔給阻塞佇列，
   消費者不找生產者要資料，而是直接從阻塞佇列裡取，阻塞佇列就相當於一個緩衝區，平衡了生產者和消費者的處理能力。
import threading
   import queue


   def producer():
      for i in range(10):
         q.put("骨頭 %s" % i)

      print("開始等待所有的骨頭被取走...")
      q.join()
      print("所有的骨頭被取完了...")


   def consumer(n):
      while q.qsize() > 0:
         print("%s 取到" % n, q.get())
         q.task_done()  # 告知這個任務執行完了
q = queue.Queue()

   p = threading.Thread(target=producer, )
   p.start()

   c1 = consumer("李闖")


   import time,random
   import queue,threading
   q = queue.Queue()
   def Producer(name):
     count = 0
while count <20:
       time.sleep(random.randrange(3))
       q.put(count)
       print('Producer %s has produced %s baozi..' %(name, count))
       count +=1
def Consumer(name):
     count = 0
while count <20:
       time.sleep(random.randrange(4))
       if not q.empty():
           data = q.get()
           print(data)
           print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))
       else:
           print("-----no baozi anymore----")
       count +=1
p1 = threading.Thread(target=Producer, args=('A',))
   c1 = threading.Thread(target=Consumer, args=('B',))
   p1.start()
   c1.start()
14.多程序模組multiprocessing
   from multiprocessing import Process
   import time


   def f(name):
      time.sleep(2)
      print('hello', name)


   if __name__ == '__main__':
      p = Process(target=f, args=('bob',))
      p.start()
      p.join()
   14.1展示程序號:
   from multiprocessing import Process
   import os


   def info(title):
      print(title)
      print('module name:', __name__)
      print('parent process:', os.getppid())
      print('process id:', os.getpid())
      print("\n\n")


   def f(name):
      info('\033[31;1mfunction f\033[0m')
      print('hello', name)


   if __name__ == '__main__':
      info('\033[32;1mmain process line\033[0m')
      p = Process(target=f, args=('bob',))
      p.start()
      p.join()
   14.2程序間通訊
14.2.1Queues方法
from multiprocessing import Process, Queue


         def f(q):
            q.put([42, None, 'hello'])


         if __name__ == '__main__':
            q = Queue()
            p = Process(target=f, args=(q,))
            p.start()
            print(q.get())  # prints "[42, None, 'hello']"
p.join()
      14.2.2Pipes方法
from multiprocessing import Process, Pipe


         def f(conn):
            conn.send([42, None, 'hello'])
            conn.close()


         if __name__ == '__main__':
            parent_conn, child_conn = Pipe()
            p = Process(target=f, args=(child_conn,))
            p.start()
            print(parent_conn.recv())  # prints "[42, None, 'hello']"
p.join()
      14.2.3Managers方法
from multiprocessing import Process, Manager


         def f(d, l):
            d[1] = '1'
d['2'] = 2
d[0.25] = None
l.append(1)
            print(l)


         if __name__ == '__main__':
            with Manager() as manager:
               d = manager.dict()

               l = manager.list(range(5))
               p_list = []
               for i in range(10):
                  p = Process(target=f, args=(d, l))
                  p.start()
                  p_list.append(p)
               for res in p_list:
                  res.join()

               print(d)
               print(l)
   14.3程序同步
from multiprocessing import Process, Lock


      def f(l, i):
         l.acquire()
         try:
            print('hello world', i)
         finally:
            l.release()


      if __name__ == '__main__':
         lock = Lock()

         for num in range(10):
            Process(target=f, args=(lock, num)).start()
15.程序池
   程序池中有兩個方法：
apply;
   apply_async;
   from  multiprocessing import Process, Pool
   import time
   def Foo(i):
      time.sleep(2)
      return i + 100
def Bar(arg):
      print('-->exec done:', arg)
   pool = Pool(5)
   for i in range(10):
      pool.apply_async(func=Foo, args=(i,), callback=Bar)
   # pool.apply(func=Foo, args=(i,))
print('end')
   pool.close()
   pool.join()  # 程序池中程序執行完畢後再關閉，如果註釋，那麼程式直接關閉。
16.協程:
   協程，又稱微執行緒，纖程。英文名Coroutine。一句話說明什麼是執行緒：協程是一種使用者態的輕量級執行緒。
   協程擁有自己的暫存器上下文和棧。協程排程切換時，將暫存器上下文和棧儲存到其他地方，在切回來的時候，恢復先前儲存的暫存器上下文和棧。因此：
   協程能保留上一次呼叫時的狀態（即所有區域性狀態的一個特定組合），每次過程重入時，就相當於進入上一次呼叫的狀態，換種說法：進入上一次離開時所處邏輯流的位置。
   協程的好處：
      無需執行緒上下文切換的開銷
      無需原子操作鎖定及同步的開銷
      原子操作(atomic operation)是不需要同步的，所謂原子操作是指不會被執行緒排程機制打斷的操作；這種操作一旦開始，就一直執行到結束，中間不會有任何 context switch （切換到另一個執行緒）。
      原子操作可以是一個步驟，也可以是多個操作步驟，但是其順序是不可以被打亂，或者切割掉只執行部分。視作整體是原子性的核心。
      方便切換控制流，簡化程式設計模型
      高併發+高擴充套件性+低成本：一個CPU支援上萬的協程都不是問題。所以很適合用於高併發處理
   缺點：
      無法利用多核資源：協程的本質是個單執行緒,它不能同時將 單個CPU 的多個核用上,協程需要和程序配合才能執行在多CPU上.當然我們日常所編寫的絕大部分應用都沒有這個必要，除非是cpu密集型應用。
      進行阻塞（Blocking）操作（如IO時）會阻塞掉整個程式
16.1利用yield實現偽協程
import time
      import queue


      def consumer(name):
         print("--->starting eating baozi...")
         while True:
            new_baozi = yield
print("[%s] is eating baozi %s" % (name, new_baozi))
         # time.sleep(1)
def producer():
         r = con.__next__()
         r = con2.__next__()
         n = 0
while n < 5:
            n += 1
con.send(n)
            con2.send(n)
            print("\033[32;1m[producer]\033[0m is making baozi %s" % n)


      if __name__ == '__main__':
         con = consumer("c1")
         con2 = consumer("c2")
         p = producer()
   16.2協程的特點
      必須在只有一個單執行緒裡實現併發
      修改共享資料不需加鎖
      使用者程式裡自己儲存多個控制流的上下文棧
      一個協程遇到IO操作自動切換到其它協程
16.3Greenlet實現協程(手動)
      # -*- coding:utf-8 -*-
from greenlet import greenlet
      def test1():
         print(12)
         gr2.switch()
         print(34)
         gr2.switch()
      def test2():
         print(56)
         gr1.switch()
         print(78)
      gr1 = greenlet(test1)
      gr2 = greenlet(test2)
      gr1.switch()
   16.4Gevent 協程自動切換
import gevent


      def func1():
         print('\033[31;1m李闖在跟海濤搞...\033[0m')
         gevent.sleep(2)
         print('\033[31;1m李闖又回去跟繼續跟海濤搞...\033[0m')


      def func2():
         print('\033[32;1m李闖切換到了跟海龍搞...\033[0m')
         gevent.sleep(1)
         print('\033[32;1m李闖搞完了海濤，回來繼續跟海龍搞...\033[0m')


      gevent.joinall([
         gevent.spawn(func1),
gevent.spawn(func2),
# gevent.spawn(func3),
])
   16.5 比較同步與非同步的效能差別
from gevent import monkey;

      monkey.patch_all()
      import gevent
      from  urllib.request import urlopen


      def f(url):
         print('GET: %s' % url)
         resp = urlopen(url)
         data = resp.read()
         print('%d bytes received from %s.' % (len(data), url))


      gevent.joinall([
         gevent.spawn(f, 'https://www.python.org/'),
gevent.spawn(f, 'https://www.yahoo.com/'),
gevent.spawn(f, 'https://github.com/'),
])
17.通過gevent實現單執行緒下的多socket併發
17.1server side :
      import sys
      import socket
      import time
      import gevent

      from gevent import socket, monkey

      monkey.patch_all()


      def server(port):
         s = socket.socket()
         s.bind(('0.0.0.0', port))
         s.listen(500)
         while True:
            cli, addr = s.accept()
            gevent.spawn(handle_request, cli)


      def handle_request(conn):
         try:
            while True:
               data = conn.recv(1024)
               print("recv:", data)
               conn.send(data)
               if not data:
                  conn.shutdown(socket.SHUT_WR)

         except Exception as  ex:
            print(ex)
         finally:
            conn.close()


      if __name__ == '__main__':
         server(8001)
   17.2client side :
      import socket

      HOST = 'localhost'  # The remote host
PORT = 8001  # The same port as used by the server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      s.connect((HOST, PORT))
      while True:
         msg = bytes(input(">>:"), encoding="utf8")
         s.sendall(msg)
         data = s.recv(1024)
         # print(data)
print('Received', repr(data))
      s.close()
18.事件驅動與非同步IO
   方式一：建立一個執行緒，該執行緒一直迴圈檢測是否有滑鼠點選，那麼這個方式有以下幾個缺點：
1. CPU資源浪費，可能滑鼠點選的頻率非常小，但是掃描執行緒還是會一直迴圈檢測，這會造成很多的CPU資源浪費；如果掃描滑鼠點選的介面是阻塞的呢？
2. 如果是堵塞的，又會出現下面這樣的問題，如果我們不但要掃描滑鼠點選，還要掃描鍵盤是否按下，由於掃描滑鼠時被堵塞了，那麼可能永遠不會去掃描鍵盤；
3. 如果一個迴圈需要掃描的裝置非常多，這又會引來響應時間的問題；
   所以，該方式是非常不好的。
   方式二：就是事件驅動模型
   目前大部分的UI程式設計都是事件驅動模型，如很多UI平臺都會提供onClick()事件，這個事件就代表滑鼠按下事件。事件驅動模型大體思路如下：
1. 
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
python# 程序/執行緒/協程 # IO:同步/非同步/阻塞/非阻塞 #  greenlet gevent # 事件驅動與非同步IO # Select\Poll\Epoll非同步IO 以及selector
     
 
                
# 程序/執行緒/協程
# IO:同步/非同步/阻塞/非阻塞
#  greenlet gevent
# 事件驅動與非同步IO
# Select\Poll\Epoll非同步IO 以及selectors模組
# Python佇列/RabbitMQ佇列　　
########### 

  
 

    

    
    
python 程序 執行緒 協程
     
 　　併發與並行：並行是指兩個或者多個事件在同一時刻發生；而併發是指兩個或多個事件在同一時間間隔內發生。在單核CPU下的多執行緒其實都只是併發，不是並行。 
  
　　程序是系統資源分配的最小單位，程序的出現是為了更好的利用CPU資源使到併發成為可能。程序由作業系統排程。 
　　執行緒的出現是為了降低 

  
 

    

    
    
python網路基礎之程序,執行緒,協程
     
  
  
  
 程序,協程,執行緒的一些總結 
 # 1.程序：作業系統分配資源的基本單元，multiprocess模組提供了Process類來代表一個程序物件,這個物件可以理解為是一個獨立的程序,可以執行另外的事情

# 建立程序時,只需要傳入一個執行函式和函式的引數,建立一個 Process 例項,用  

  
 

    

    
    
關於Python的程序執行緒協程之大話多程序多執行緒
     
 
								
								            
							
							
							大話多程序多執行緒


  “程序——資源分配的最小單位，執行緒——程式執行的最小單位”






程序：


  是程式執行時的一個例項，即它是程式已經執行到課中程度的資料結構的彙集。從核心的觀點看 

  
 

    

    
    
程序執行緒協程區別
     
  
 
 現在多程序多執行緒已經是老生常談了，協程也在最近幾年流行起來。python中有協程庫gevent，py web框架tornado中也用了gevent封裝好的協程。本文主要介紹程序、執行緒和協程三者之間的區別。 
 一、概念 
 　　1、程序 
 程序是具有一定獨立功能的程式關於某個資料集合上的一次執 

  
 

    

    
    
程序,執行緒,協程的對比
     
  
  
  
 1.程序是資源分配的單位 2.執行緒是作業系統排程的單位 3.程序切換需要的資源最大，效率低 4.執行緒切換需要的資源一般，效率一般 5.協程切換任務資源很小，效率高 6.多程序，多執行緒根據cpu核數不一樣可能是並行的，但是協程是在一個執行緒中，所以是併發 
 協程(coroutines) 

  
 

    

    
    
程序&執行緒&協程
     
 
								
								            
						
                程序：程式的一次執行，在系統內有獨立的地址空間、記憶體，以管理獨立的程式執行、切換。不同程序通過程序間通訊來通訊，由於程序比較重量，佔據獨立的記憶體，所以上下文程序間的切換開銷（棧、暫存器、虛擬記憶體、 

  
 

    

    
    
linux程序-執行緒-協程上下文環境的切換與實現
     
 
                一：程序-執行緒-協程簡介程序和執行緒的主要區別是：程序獨享地址空間和資源，執行緒則共享地址空間和資源，多執行緒就是多棧。1、程序程序是具有一定獨立功能的程式關於某個資料集合上的一次執行活動,程序是系統進行資源分配和排程的一個獨立單位。每個程序都有自己的獨立記憶體空間，不同程 

  
 

    

    
    
程序/執行緒/協程/管程/纖程  筆記
     
 
							
							
							

下面是『雜談』，以前的我不重視基本概念。現在就需要惡補了。

認識CPU

百度百科


  中央處理器（CPU，Central Processing Unit）是一塊超大規模的積體電路，是一臺計算機的運算核心（Core）和控制核心（ Control Uni 

  
 

    

    
    
python 多程序/多執行緒/協程 同步非同步
     
 這篇主要是對概念的理解： 
1、非同步和多執行緒區別：二者不是一個同等關係,非同步是最終目的,多執行緒只是我們實現非同步的一種手段。非同步是當一個呼叫請求傳送給被呼叫者,而呼叫者不用等待其結果的返回而可以做其它的事情。實現非同步可以採用多執行緒技術或則交給另外的程序來處理。多執行緒的好處，比較容易的實現了 非 

  
 

    

    
    
Python程序,執行緒以及協程對比
     
  
  
  
 執行緒：一份程式碼資源有多個箭頭同時執行 程序：拷貝多份程式碼資源中只存在一個箭頭(執行緒)來執行 協程 : 利用程式的阻塞或者暫停時間完成多工 即：資源分配的程式碼是程序，而執行程式碼的是執行緒， 可以理解為程序是工廠的一條流水線，其中執行緒就是流水線上的工人。 協程利用閒散時間加班的有志 

  
 

    

    
    
python爬蟲——多執行緒+協程（threading+gevent）
     
  
  
  
 以下摘自這篇文章：https://blog.csdn.net/qq_23926575/article/details/76375337 
 在爬蟲中廣泛運用的多執行緒+協程的解決方案，親測可提高效率至少十倍以上。 本文既然提到了執行緒和協程，我覺得有必要在此對程序、執行緒、協程做一個簡單的對 

  
 

    

    
    
go語言對映map的執行緒協程安全問題
     
 
                
見程式碼中註釋：

package main

import (
       "fmt"
       "sync"
)

func main()  {

       m := map[string]int{"a":1, "b":2, "c":3, "d":4, "e" 

  
 

    

    
    
python程序執行緒多執行緒鎖
     
 
							
							
							程序：

程序就是一段程式的執行過程。

執行緒：

通常在一個程序中可以包含若干個執行緒，當然一個程序中至少有一個執行緒，不然沒有存在的意義。執行緒可以利用程序所擁有的資源，在引入執行緒的作業系統中，通常都是把程序作為分配資源的基本單位，而把執行緒作為獨立執行 

  
 

    

    
    
python 程序執行緒
     
 
                
1.多程序
要讓Python程式實現多程序（multiprocessing），我們先了解作業系統的相關知識。
Unix/Linux作業系統提供了一個fork()系統呼叫，它非常特殊。普通的函式呼叫，呼叫一次，返回一次，但是fork()呼叫一次，返回兩次，因為作業系統自動把當 

  
 

    

    
    
python多執行緒程式設計之Queue---put/get 方法的阻塞
     
 
                python 中，佇列是執行緒間最常用的交換資料的形式。Queue模組是提供佇列操作的模組，雖然簡單易用，但是不小心的話，還是會出現一些意外。

1. 阻塞模式導致資料汙染

import Queue
       q = Queue.Queue(10)
       for 

  
 

    

    
    
Python多執行緒、多程序和協程的例項講解
     
 執行緒、程序和協程是什麼 
執行緒、程序和協程的詳細概念解釋和原理剖析不是本文的重點，本文重點講述在Python中怎樣實際使用這三種東西 
參考： 程序、執行緒、協程之概念理解 
程序（Process）是計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎。執 

  
 

    

    
    
Python 多執行緒 多程序 協程 yield
     
  
 
 python中多執行緒和多程序的最大區別是穩定性和效率問題 
 多程序互相之間不影響,一個崩潰了不影響其他程序,穩定性高 多執行緒因為都在同一程序裡,一個執行緒崩潰了整個程序都完蛋 
 多程序對系統資源開銷大,多執行緒對系統資源開銷小,所以這方面來說多執行緒會比多程序快一點點 
 關於執行 

  
 

    

    
    
python多執行緒、多程序、協程的使用
     
  
 
 本文主要介紹多執行緒、多程序、協程的最常見使用，每個的詳細說明與介紹有時間會在以後的隨筆中體現。 
 一、多執行緒 
 1.python通過兩個標準庫thread和threading提供對執行緒的支援。thread提供了低級別的、原始的執行緒以及一個簡單的鎖。threading通過對thread模組 

  
 

    

    
    
python 多執行緒， 多程序， 協程
     
 1. 介紹： 
threading用於提供執行緒相關的操作，執行緒是應用程式中工作的最小單元。python當前版本的多執行緒庫沒有實現優先順序、執行緒組，執行緒也不能被停止、暫停、恢復、中斷。 
2. 1  執行緒執行函式 
 
 #!/bin/python
#coding:utf8

import