進程與線程相關

1.操做系統/應用程序
   a.硬件
      硬盤,CPU,主板,顯卡,內存,電源...
   b.軟件,應用程序
      QQ,pycharm,WPS
   c.裝系統(系統也是一個軟件)
      系統就是一個由程序員寫出來的軟件
2.併發和並行
    併發:僞的,只是執行的速度特別快,人感受不到停頓
    並行:真的,幾個工做同時進行
3.線程,進程

    a.單進程,單線程的應用,
      print(666)
    b.什麼是進程,什麼是線程.
      python本身沒有,python中調用的是操做系統中的進程,和線程
　　

　　 c.單進程,多線程的應用程序
        import threading
        import time
        print(666)
        def task(arg):
            print(arg)
        arg=int(input('請輸入一個數'))
        t=threading.Thread(target=task,args=(arg,))
        time.sleep(10)
        t.start()

一個應用程序(軟件),能夠有多個進程(默認只有一個),一個進程中能夠有多個線程(默認只有一個)
    d.
　　　　之前:

import time list=['思路.png','111.PNG','尚宏運.txt'] for row in list: with open(row,mode='rb') as f: time.sleep(5)  #停頓五秒出來一個,一共停頓三個五秒
        print(f.read())

(1)寫好代碼
(2)交給解釋器取運行
(3)解釋器讀取代碼,交給操做系統去執行,根據代碼的內容,建立多少個線程/進程去執行(單進程/單線程)
(4)操做系統調用硬件
　　　　如今

import time import threading list=['思路.png','111.PNG','尚宏運.txt'] def task(arg): with open(arg,mode='rb') as f: time.sleep(5)  #停頓一個五秒後所有都出來
        print(f.read()) for arg in list: t=threading.Thread(target=task,args=(arg,)) t.start()

(1)寫好代碼
(2)交給解釋器去運行
(3)解釋器讀取代碼,交給操做系統去執行 ,根據代碼的內容,建立多少個進程/線程去執行(單進程/4線程)
(4)操做系統調用硬件

4. Python中線程和進程（GIL鎖）
  

          GIL鎖,全局解釋器鎖,用於控制一個進程同一時刻,只有一個線程被CPU調度
          GIL鎖的存在限制了,在Python中,一個進程中,最多隻能有一個線程工做
          擴展：默認GIL鎖在執行100個cpu指令。
                import sys
                v1 = sys.getcheckinterval()#（過時時間）
                print(v1)  3執行100個CPU指令,就換另外一個線程
      python多線程狀況下:
          計算密集型操做:效率低
          IO操做:效率高
      python多進程狀況下:
          計算密集型操做:效率高 (浪費資源),不得已而爲之
          IO操做:效率高(浪費資源),更多用多線程解決
      結論:之後的用法
          IO密集型用多線程
          計算密集型用多進程
      Java多線程的狀況下:
           計算密集型操做:效率高
           IO操做:效率高

5.Python線程編寫
(1)多線程對於計算密集型無用

import time import threading v1=[11,22,33] v2=[111,222,333] def func(data,num): time.sleep(2) for i in range(len(data)): data[i]=data[i]+num t=threading.Thread(target=func,args=(v1,1)) t.start() t1=threading.Thread(target=func,args=(v2,100)) t1.start() time.sleep(6.1) print(v1)#得到結果一共須要6秒左右
print(v2)

(2)多進程對於IO操做有用

import time import threading list=['思路.png','111.PNG','尚宏運.txt'] def task(arg): with open(arg,mode='rb') as f: time.sleep(5)  #停頓一個五秒後所有都出來,而不是15秒
        print(f.read()) for arg in list: t=threading.Thread(target=task,args=(arg,)) t.start()

(3)線程編寫具體用法　　

　　①線程的基本使用

import threading def func(arg): print(arg) t=threading.Thread(target=func,args=(11,)) t.start() #123
print(123)  #123

　　②主線程默認等子線程執行完畢

import time import threading def func(arg): time.sleep(2) print(arg) t1=threading.Thread(target=func,args=(11,)) t1.start() t2=threading.Thread(target=func,args=(11,)) t2.start() print(123) 123  #先出來
11   #等兩秒
11   #兩個11一塊兒出來

　　③讓主線程不在等子線程執行完,主線程終止了全部子線程就都執行完  t2.setDaemon(True)

import time import threading def func(arg): time.sleep(2) print(arg) t1=threading.Thread(target=func,args=(11,)) t1.setDaemon(True) t1.start() t2=threading.Thread(target=func,args=(11,)) t2.setDaemon(True) t2.start() print(123)  #123

　　④開發者能夠控制主線程等待子線程的最多等待時間
　　　　沒有參數:讓主程序在這裏等着,等這個子程序執行完畢才能夠繼續往下走

import time import threading def func(arg): time.sleep(2) print(arg) t1=threading.Thread(target=func,args=(11,)) t1.start() t1.join() t2=threading.Thread(target=func,args=(22,)) t2.start() t2.join() print(123)

　　　　有參數:讓主程序在這裏最多等n秒,不管是否執行完畢,都會繼續往下走,可是若是此時走到了最後,
　　　　子程序還沒執行完,程序不會中止,而是等子程序執行完再中止

import time import threading def func(arg): time.sleep(arg) print(arg) t1=threading.Thread(target=func,args=(4,)) t1.start() t1.join(1) t2=threading.Thread(target=func,args=(5,)) t2.start() t2.join(1) print(123)

　　⑤線程名稱

import threading def func(arg): t=threading.current_thread() name=t.getName() print(name,arg) t1=threading.Thread(target=func,args=(11,)) t1.setName('我叫t1') t1.start() t2=threading.Thread(target=func,args=(12,)) a=t2.setName('我叫t2') t2.start() print(123)

　　⑥現成本質:t.start()並非開始線程的意思,而是告訴CPU,我已經準備就緒,你能夠調度我了

import threading def func(arg): print(arg) t=threading.Thread(target=func,args=(11,)) t.start() print(123)

　　⑦面向對象版本的多線程

　　　　通常寫法

import threading def func(arg): print(arg) t=threading.Thread(target=func,args=(11,)) t.start()# 實際上,就是執行threading模塊中Thread類的run方法,run方法就是執行target=xxx中的xxx方法

　　　　還能夠這樣作

import threading class MyThread(threading.Thread):  #本身寫一個類,直接繼承Thread類,要執行run方法,首先從子類(本身寫的類開始找),效果徹底相同
    def run(self): print(11111,self._args,self._kwargs) t1=MyThread(args=(11,)) t1.start() t1=MyThread(args=(22,)) t1.start()

總結:
  Ⅰ應用程序,進程,線程之間的關係
      一個應用程序(軟件),能夠有多個進程(默認只有一個),一個進程中能夠有多個線程(默認只有一個)
  Ⅱ爲何要建立線程
      線程是CPU工做的最小單元,在Java或C#中,建立線程能夠利用多和優點實現並行操做
  Ⅲ爲何要建立進程
      進程與進程之間可以實現數據隔離(進程是爲了提供環境讓線程工做)