• 一.程序的建立
  • 1.1 程序建立方式一
  • 1.2 程序建立方式二
  • 1.3 建立程序windows和linux與mac區別
  • 1.4 程序實現併發
• 二.程序其他知識
  • 2.1 join方法
  • 2.2 程序資料預設隔離
  • 2.3 程序的一些屬性和方法
  • 2.4 殭屍程序與孤兒程序
  • 2.5 守護程序
• 三.互斥鎖
  • 3.1 互斥鎖的應用
  • 3.2 其他鎖知識

一.程序的建立

1.1 程序建立方式一

1.2 程序建立方式二

1.3 建立程序windows和linux與mac區別

1.4 程序實現併發

二.程序其他知識

2.1 join方法

2.2 程序資料預設隔離

2.3 程序的一些屬性和方法

2.4 殭屍程序與孤兒程序

2.5 守護程序

三.互斥鎖

3.1 互斥鎖的應用

3.2 其他鎖知識

一.程序的建立

1.1 程序建立方式一

# 建立程序的本質就是在記憶體開闢一個新的空間執行相應的程式碼也可以是一份程式碼多個程序
from multiprocessing import Process
import time


def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)


if __name__ == '__main__':
    p = Process(target=task, args=('jason',))  # 建立一個程序物件
    p.start()  # 告訴作業系統建立一個新的程序
    print('主程序')
 

1.2 程序建立方式二

from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self, username):
        self.username = username
        super().__init__()
    def run(self):
        print('你好啊 小姐姐',self.username)
        time.sleep(3)
        print('get out!!!',self.username)
if __name__ == '__main__':
    p = MyProcess('tony')
    p.start()
    print('主程序')
 

1.3 建立程序windows和linux與mac區別

​ 在windows中建立程序是以匯入模組的方式進行 所以建立程序的程式碼必須寫在__main__子程式碼中否則會直接報錯 因為在無限制建立程序

​ 在linux和mac中建立程序是直接拷貝一份原始碼然後執行 不需要寫在__main__子程式碼中

1.4 程序實現併發

# 服務端
import socket
from multiprocessing import Process

def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    return server
def talk(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        info=f'服務端{data}'
        info=info.encode()
        sock.send(info)

if __name__ == '__main__':
    server=get_server()
    while True:
        sock, addr = server.accept()
        p = Process(target=talk, args=(sock, ))
        p.start()
# 客戶端1
import socket


client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    info=input('>>>:').strip().encode()
    client.send(info)
    data = client.recv(1024)
    print(data.decode('utf8'))
# 客戶端二
import socket


client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    info=input('>>>:').strip().encode()
    client.send(info)
    data = client.recv(1024)
    print(data.decode('utf8'))

二.程序其他知識

2.1 join方法

# join方法可以實現讓子程序執行完了在執行主程序
from multiprocessing import Process
import time
def task(name, n):
    print(f'{name} is running')
    time.sleep(n)
    print(f'{name} is over')
if __name__ == '__main__':
    p1 = Process(target=task, args=('jason', 1))
    p2 = Process(target=task, args=('tony', 2))
    p3 = Process(target=task, args=('kevin', 3))
    start_time = time.time()
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    end_time = time.time() - start_time
    print('主程序', f'總耗時:{end_time}') 

2.2 程序資料預設隔離

# 記憶體可以看成是有很多個小隔間組成的 彼此不干擾
from multiprocessing import Process
money = 999
def task():
    global money  # 區域性修改全域性不可變型別
    money = 666
if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()  # 確保子程序程式碼執行結束再列印money
    print(money)
"""預設隔離  但是可以通過一些技術打破"""

2.3 程序的一些屬性和方法

"""
程序號如何檢視
	windows: 			tasklist結果集中PID
	mac:					ps -ef
"""
1.檢視程序號的方法
	1.1.current_process函式
  	from multiprocessing import Process, current_process
    current_process().pid
 	# 獲取程序號的用處之一就是可以通過程式碼的方式管理程序
  	windows  			taskkill關鍵字
    mac/linux  		kill關鍵字
  1.2.os模組
  	os.getpid()  # 獲取當前程序的程序號
    os.getppid()  # 獲取當前程序的父程序號
2.殺死子程序
	terminate()
3.判斷子程序是否存活
	is_alive()

2.4 殭屍程序與孤兒程序

殭屍程序
	# 為什麼主程序預設需要等待子程序結束才會結束
  所有的子程序在執行結束之後都會變成殭屍程序(死了沒死透)
  還保留著pid和一些執行過程的中的記錄便於主程序檢視(短時間儲存)
  這些資訊會被主程序回收(殭屍徹底死了)
  	1.主程序正常結束
    2.呼叫join方法
  
孤兒程序
	# 子程序存活著 父程序意外死亡
  子程序會被作業系統自動接管(兒童福利院)

2.5 守護程序

"""
守護即死活全部參考守護的物件
	物件死立刻死
"""
from multiprocessing import Process
import time


def task(name):
    print(f'大內總管:{name}正常活著')
    time.sleep(3)
    print(f'大內總管:{name}正常死了')

if __name__ == '__main__':
    p = Process(target=task, args=('趙公公',))
    # 必須寫在start前面
    p.daemon = True  # 將子程序設定為守護程序:主程序結束 子程序立刻結束
    p.start()
    print('皇帝Jason壽終正寢')

三. 互斥鎖

3.1 互斥鎖模擬搶票

import json
import multiprocessing import Process,Lock
import time
import random
# 查票介面
def search(name):
    wieh open(r'ticket_data.json','r',encoding='utf8')as f:
        data=json.load(f)
    print(f'{name}查詢當前餘票：%s'% data.get('ticket_num'))
# 買票
def buy(name):
    '''
    點選買票是需要再次查票的 因為期間其他人可能已經把票買走了
    '''
    # 1.查票
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    time.sleep(random.randint(1, 3))
    # 2.判斷是否還有餘票
    if data.get('ticket_num') > 0:
        lock.acquire()
        data['ticket_num'] -= 1
        with open(r'ticket_data.json', 'w', encoding='utf8') as f:
            json.dump(data, f)
        lock.release()
        print(f'{name}搶票成功')
    else:
        print(f'{name}搶票失敗 沒有餘票了')


def run(name):
    search(name)
    buy(name)
# 模擬多人同時搶票
if __name__ == '__main__':
    lock=Lock()
    for i in range(1, 10):
        p = Process(target=run, args=('使用者:%s' % i,lock))
        p.start()

3.2 其他鎖知識

行鎖:針對行資料加鎖 同一時間只能一個人操作
表鎖:針對表資料加鎖 同一時間只能一個人操作

悲觀鎖：每次去拿資料的時候都認為別人會修改，所以每次在拿資料的時候都會上鎖，這樣別人想拿這個資料就會block直到它拿到鎖。傳統的關係型資料裡邊
就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖

樂觀鎖：每次去拿資料的時候都認為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個資料，可以使用版本號等機制，
樂觀鎖適用於多讀的應用型別，這樣可以提高吞吐量