網路程式設計02 併發理論

2022-09-14 09:30:18 字數 4108 閱讀 1032

import socket

s = socket.socket() # 建立網路傳輸,預設tcp協議

s.bind((ip+port)) # 繫結ip+埠

s.listen(5) # 半連線池

sock, addr = s.accept # 監聽,三次握手的lisent態

sock.recv(1024) # 接收內容

sock.send(傳送的內容) # 傳送內容

c = socket.socket()

c.connect((ip+port))

大檔案如何傳輸

如何校驗檔案資料的一致性

使用hashlib模組對檔案內容做加密處理,之後傳送成功之後取出隨機字串做對比

切片解密對比

讀取檔案部分內容加密(劃分區域)

資料儲存

for迴圈一行行傳送,一行行儲存

昨日**務必掌握

# 服務端

import socket

amg = socket.socket(type = socket.sock_dgram) # udp協議

amg.bind(('127.0.0.1', 9000)) # 繫結ip位址

msg, addr = amg.rescvfrom(1024)

amg.sendto(傳送的內容,addr傳送的位址)

amg.close()

# 客戶端

import socket

ip_port = ('127.0.0.1', 9000)

udp_sk = socket.socket(type=socket.sock_dgram)

udp_sk.sendto(內容,ip_port)

back, addr = udp_sk.recvfrom(1024)

print(back.decode('utf-8'),addr)

# 建議qq程式練習

學習併發程式設計其實就是現在學習作業系統的發展史(底層邏輯)

穿孔卡片時代:

聯機批處理系統

離線批處理系統

前提:針對單核cpu(同一時間計算機只能高一件事)

單道技術(序列)

多道技術(單核)

當某個程式進入io狀態,才做系統會自動剝奪改程式的cpu執行許可權

當某個程式長時間占用cpu時,那麼作業系統也會剝奪改程式的cpu的執行許可權

並行與併發

簡單小問題:

星軌:微博可以同時支援多個星軌

程序與程式的區別

單核情況下的程序排程

程序三狀態圖

同步&非同步(用於面熟任務的提交方式)

非同步:阻塞&非阻塞(描述任務的執行狀態)

# **層面建立程序

# 高階模組

from mulirocessing import process

import time

def test(name):

print('%s正在執行'%name)

time.sleep(3)

print('%s已經結束'%name)

if __name__ = '__main__':

p = process(target=test, args=('kk',)) # s生成乙個程序物件

p.start() # 告訴作業系統開設乙個新程序,並執行。非同步提交

'''在win系統中開設程序類似於匯入模組

從上往下再次執行**

一定要在__main__判斷語句內執行開設程序的**塊

if __name__ = '__main__':

print(123)

在linux系統中直接將**完整的複製乙份執行

不需要__main__判斷語句內執行

'''# 類建立程序

class myprocess(process):

def __init__(self, name):

super().__init__()

self.name = name

def run(self):

print('%s正在執行'%name)

time.sleep(3)

print('%s已經結束'%name)

if __name__ == '__main__':

p = myprocess('kk')

p.start()

from multiprocessing import process

import time

def test(name, n):

print('%s is running' % name)

time.sleep(n)

print('%s is over' % name)

if __name__ == '__main__':

p_list =

start_time = time.time()

for i in range(1, 4):

p = process(target=test, args=(i, i))

p.start()

# p.join() # 序列 9s+

for p in p_list:

p.join()

print(time.time() - start_time)

""" p = process(target=test, args=('jason',))

p1 = process(target=test, args=('kevin',))

p2 = process(target=test, args=('oscar',))

p.start()

p1.start()

p2.start()

""" print('主程序')

# 程序間資料是相互隔離的

from multiprocessing import process

money = 100

def test():

global money

money = 999

if __name__ == '__main__':

p = process(target=test)

p.start()

# 先確保子程序執行完畢了 再列印

p.join()

print(money)

from mulirocessing import process

import time

import os

def test(name):

print('%s正在執行'%name)

time.sleep(3)

print('%s已經結束'%name)

if __name__ = '__main__':

p = process(target=test, args=('kk',)) # s生成乙個程序物件

p.start() # 告訴作業系統開設乙個新程序,並執行。非同步提交

p.join() # 等待子程序執行結束在執行主程序

p.terminate() # 立刻結束子程序

print(p.is_alive()) # 檢視程序是否存在,返回布林值

print(current_process().pid) # 檢視當前程序號

print(os.getpid()) # 檢視當前程序號

print(os.getppid()) # 檢視父程序號

"""1.current_process檢視程序號

2.os.getpid() 檢視程序號 os.getppid() 檢視父程序程序號

3.程序的名字,p.name直接預設就有,也可以在例項化程序物件的時候通過關鍵字形式傳入name=''

3.p.terminate() 殺死子程序

4.p.is_alive() 判斷程序是否存活 3,4結合看不出結果,因為作業系統需要反應時間。主程序睡0.1即可看出效果

"""

時間伺服器的實現原理

2、遠端時間同步

linux多台伺服器定時任務

併發程式設計理論

併發 在作業系統中,是指乙個時間段中有幾個程式都處於已啟動執行到執行完畢之間,且這幾個程式都是在同乙個處理機上執行,但任乙個時刻點上只有乙個程式在處理機上執行。簡言之,是指系統具有處理多個任務的能力。當系統有乙個以上cpu時,則執行緒的操作有可能非併發。當乙個cpu執行乙個執行緒時,另乙個cpu可以...

36 併發程式設計理論

多道技術是基於單核背景下產生的 cpu 執行過程 單核 cpu 同一時間只能執行乙個任務,這個任務不結束,不能執行其他任務 cpu 在執行a任務時,a任務發生了 io 操作或者是執行時間過長時,此時 cpu 可以將 a 儲存狀態 然後再切換去執行b任務。等到執行遇到 io操作或者執行時間過長時 再將...

網路程式設計理論

tcp ip協議族 是很多協議的總稱 四層協議 2.傳輸層 tcp udp 3.網路層 ip 4.介面層 mac 應用層 tcp ip mac 電子裝置在網路上的唯一標識 255.255.255.255 1111 1111.1111 1111.1111 1111.1111 1111 32位 4g 2...