osi7層模型及執行緒和程式

Bound_w發表於2018-09-10
模型執行緒

埠的作用：

　　在同一臺電腦上，為了讓不同 的程式分離開來！

http:網站預設埠是80

https:網站預設埠是443

osi七層模型：

1.應用層：軟體

2.表示層：接收資料

3.會話：保持登入或連結狀態

4.傳輸：tcp/udp

5.網路:IP

6.資料鏈路MAC

7.物理：把資料轉化成電訊號傳送

TCP：的三次握手和四次揮手：

三次握手：客戶端向服務端發起連結請求

四次揮手：客戶端和服務端斷開連結

 

 

 

執行緒和程式：

1.作業系統/應用程式:

　　a.硬體：硬碟，CPU，主機板，顯示卡，記憶體條，記憶體、、、、

　　b.系統：就是軟體，控制計算機的硬體，讓他們相互配合。

　　c.軟體：安裝一些功能

2.操作中的併發：

　　併發（偽）：由於執行速度特別快，人感覺不到停頓

　　並行（真）：建立多個人同時操作某個功能。

 

3.其他語言的執行緒/程式

　　單程式，單執行緒的應用程式：egg：print('666')

　　什麼是執行緒，什麼是程式？

　　執行緒：

　　　　工作的最小的單元，共享程式中的所有資源，每個執行緒可以分擔一些任務，最終能夠完成結果。

　　程式：

　　　　獨立開闢的記憶體，進行資料之間的隔離

　　一個用應用程式（軟體），可以有多個程式，（預設只有一個），一個程式中可以有多個執行緒（預設一個）

執行緒的使用：

　　1.基本使用

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

 

　　2.主執行緒預設等子執行緒執行完畢

import time
def func(arg):
    time.sleep(arg)
    print(arg)


t1 = threading.Thread(target=func,args=(3,))
t1.start()

t2 = threading.Thread(target=func,args=(9,))
t2.start()

print(123)
#123
3
9
先執行主執行緒，在執行子執行緒，主執行緒等子執行緒執行完畢才結束程式

 

　　3.主執行緒不再等子執行緒，主執行緒終止，所有子執行緒終止

import threading
import time
def func(arg):
    time.sleep(2)
    print(arg)
t1=threading.Thread(target=func,args=(3,))
t1.setDaemon(True)
t1.start()
t2=threading.Thread(target=func,args=(3,))
t2.setDaemon(True)
t2.start()
print(123)
#123
#引入sys模組的setDaemon方法，讓主執行緒不再等待子執行緒。

 

　　4.開發者可以人為的控制讓主執行緒等待子執行緒（最多等待的時間）

import time
import threading
def func(arg):

    time.sleep(0.01)#根據時間的長短，執行結果會不同
    print(arg)
print("建立子執行緒t1")
t1=threading.Thread(target=func,args=(3,))
t1.start()
t1.join(2)
#join有引數的話，讓主執行緒最多等n秒，無論n秒後是否執行完畢，都會往下執行
#join沒有引數的話，讓主執行緒一直等著，等t1(子執行緒)執行完後，才會繼續往下執行
print('建立子執行緒t2')
t2=threading.Thread(target=func,args=(9,))
t2.start()
t2.join(2)
print(123)
#建立子執行緒t1
3
建立子執行緒t2
9
123

 

　　5.執行緒名稱

import threading
def func(arg):
    t = threading.current_thread()#獲取當前執行該函式的執行緒物件
    name=t.getName()#根據當前的執行緒物件獲取當前的執行緒名稱
    print(name,arg)
t1=threading.Thread(target=func,args=(11,))
t1.setName('Jave yang')
t1.start()
#Jave yang 11

 

　　6.執行緒本質

# 先列印：11？123？
def func(arg):
    print(arg)

t1 = threading.Thread(target=func,args=(11,))
t1.start()
# start 是開始執行執行緒嗎？不是
# start 告訴cpu，我已經準備就緒，你可以排程我了。
print(123)

 

　　7.物件導向版本的多執行緒

class MyThread(threading.Thread):

    def run(self):
        print(11111,self._args,self._kwargs)

t1 = MyThread(args=(11,))
t1.start()

t2 = MyThread(args=(22,))
t2.start()
print('end')


11111 (11,) {}
11111 (22,) {}
end

 

 

4.python中執行緒和程式（GIL鎖）

為什麼會有GIL鎖：python創始人在開發這門語言時，目的快速把語言開發出來，加上鎖，切換時按照100條位元組指令來進行執行緒之間切換。

GIL鎖：全域性直譯器鎖，用於限制一個程式同一時刻只有一個執行緒能被CPU呼叫。

擴充套件：預設GIL鎖在執行100個CPU指令後，才會切換　　　　使用sys模組檢視sys.getchekinterval

lock=threading.Rlock()

lock.acquire()加鎖，表示在此區域同一時刻只能有一個執行緒執行

lock.release()釋放鎖

import time
import threading

lock = threading.RLock()

n = 10

def task(i):
    print('這段程式碼不加鎖',i)

    lock.acquire() # 加鎖，此區域的程式碼同一時刻只能有一個執行緒執行
    global n
    print('當前執行緒',i,'讀取到的n值為：',n)
    n = i
    time.sleep(1)
    print('當前執行緒',i,'修改n值為：',n)
    lock.release() # 釋放鎖


for i in range(10):
    t = threading.Thread(target=task,args=(i,))
    t.start()

 

 

 

 

 

總結：1.作業系統幫開發者操作硬體

　　   2.程式設計師寫好程式碼在作業系統上執行（依賴直譯器）

　　   3.python多執行緒情況下，計算密集型操作，效率低！（GIL），IO操作，效率高！

　　　python多程式情況下，計算密集型操作，效率高（浪費資源），IO操作，效率高（浪費資源）

　　   4.Java多執行緒情況下，計算密集型操作，效率高！，IO操作，效率高！

　　　Java多程式情況下，計算密集型操作，效率高（浪費資源），IO操作，效率高（浪費資源）

總結：

1.應用程式/程式/執行緒的關係***********************（面試）

為了使應用程式能夠執行，建立了程式幫助程式之間進行隔離，為執行緒的工作提供了工作環境，執行緒幫助完成程式的操作！

2.為什麼要建立執行緒？（提供工作）

　　執行緒是CPU工作的最小單元，建立執行緒可以利用多核優勢實現操作（Java、c#）

3.為什麼要建立程式（提供工作的環境）：   程式和程式之間做資料隔離（Java、c#）

4.python

　　a.  python中的GIL鎖造成多執行緒無法利用多核優勢，用程式來處理（浪費資源）

　　b.  執行緒的建立：

　　c.  join  ：人為的控制讓主執行緒等待子執行緒

　　　join有值時，讓主執行緒等子執行緒n秒，如果n秒後子執行緒還沒有執行完，就繼續執行下面的程式碼，只等n秒

　　　join沒有值得時候，讓主執行緒等到子執行緒執行完之後才會執行後面的程式碼

　　d.  setdeamon 引入sys模組的setDaemon方法，讓主執行緒不再等待子執行緒。主執行緒執行完畢，子執行緒必須要執行完畢，沒有執行完就不管了

       e.  threading .current_thread()獲取到執行當前函式的執行緒物件，.getName()#根據當前的執行緒物件獲取當前的執行緒名稱

　　f:獲取執行緒的id

　　.  鎖，獲得鎖，釋放鎖

 

 

 

 

 

5.python 執行緒編寫+鎖

 

6.小爬蟲

 

相關文章