• 程式碼建立程序
  • 建立程序的方式有哪些
    • 程式碼建立的兩種方式
    • 程序迴圈
• join方法
• 程序間資料預設隔離
• 程序物件相關屬性和方法
  • 檢視程序的方法
    • cmd
    • python程式碼
      • current_process函式
      • os模組
• 殭屍程序與孤兒程序
  • 殭屍程序
  • 孤兒程序
• 守護程序
• 互斥鎖

程式碼建立程序

建立程序的方式有哪些

• 滑鼠雙擊桌面一個應用圖示
• 程式碼建立

程式碼建立的兩種方式

# 第一種程式碼建立程序的方式
from multiprocessing import Process
import time


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


if __name__ == '__main__':
    p = Process(target=task, args=('meta',))  # 建立一個程序物件
    p.start()  # 建立一個新的程序
    print('主程序')
# 第二種程式碼建立程序的方式
from multiprocessing import Process
import time


class MyProcess(Process):
    def __init__(self, process_name):
        self.process_name = process_name
        super().__init__()

    def run(self):
        print('the subprocess %s is running' % self.process_name)
        time.sleep(3)
        print('the subprocess %s is over' % self.process_name)


if __name__ == '__main__':
    p = MyProcess('mi_chat')
    p.start()
    print('主程序')
 

程序迴圈

# 客戶端
import socket


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

count = 1
send_msg = input('請輸入傳送的內容>>>:').strip()
while count < 9:
    client.send(send_msg.encode('utf8'))
    data = client.recv(1024)
    count += 1
    print(data.decode('utf8'))
# 服務端
import socket
from multiprocessing import Process


def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8066))
    server.listen(4)
    return server


def talk(sock):
    count = 1
    while count < 9:
        count += 1
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(f'我們已經收到您的訊息'.encode('utf8'))


if __name__ == '__main__':
    server = get_server()
    count = 1
    while count < 9:
        sock, addr = server.accept()
        count += 1
        p = Process(target=talk, args=(sock,))
        p.start()
 

join方法

# join方法讓主程序程式碼等待子程序程式碼執行完畢再執行

from multiprocessing import Process
import time


def task(process_name, time_arg):
    print(f'the subprocess: {process_name} is running')
    time.sleep(time_arg)
    print(f'the subprocess: {process_name} is over')


if __name__ == '__main__':
    p1 = Process(target=task, args=('qq', 1))
    p2 = Process(target=task, args=('tmall', 2))
    p3 = Process(target=task, args=('jd', 3))
    p4 = Process(target=task, args=('pxx', 4))
    start_time = time.time()
    p1.start()
    p2.start()
    p3.start()
    p4.start()
    p1.join()
    p2.join()
    p3.join()
    p4.join()
    end_time = time.time()
    sum_time = end_time - start_time
    print('主程序', f'總耗時:{sum_time}')  # 主程序 總耗時:4.281822919845581
# start一個join交替執行的情況
from multiprocessing import Process
import time


def task(process_name, time_arg):
    print(f'the subprocess: {process_name} is running')
    time.sleep(time_arg)
    print(f'the subprocess: {process_name} is over')


if __name__ == '__main__':
    p1 = Process(target=task, args=('qq', 1))
    p2 = Process(target=task, args=('tmall', 2))
    p3 = Process(target=task, args=('jd', 3))
    p4 = Process(target=task, args=('pxx', 4))
    start_time = time.time()
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    p4.start()
    p4.join()
    end_time = time.time()
    sum_time = end_time - start_time
    print('主程序', f'總耗時:{sum_time}')  # 主程序 總耗時:10.786401271820068
 

程序間資料預設隔離

from multiprocessing import Process

nationality = 'China'


def task():
    global nationality
    nationality = 'USA'


if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()  # 目的是子程序程式碼執行結束再執行列印操作
    print(nationality)  # China

程序物件相關屬性和方法

檢視程序的方法

cmd

windows: tasklist
mac: ps -ef

python程式碼

current_process函式

# current_process函式
from multiprocessing import Process,current_process
import time


class MyProcess(Process):
    def __init__(self, process_name):
        self.process_name = process_name
        super().__init__()

    def run(self):
        print('the subprocess %s is running' % self.process_name)
        print(current_process().pid)
        time.sleep(3)
        print('the subprocess %s is over' % self.process_name)


if __name__ == '__main__':
    p = MyProcess('mi_chat')
    p.start()
    print('主程序')
    print(current_process().pid)

os模組

# os模組
from multiprocessing import Process,current_process
import time
import os

class MyProcess(Process):
    def __init__(self, process_name):
        self.process_name = process_name
        super().__init__()

    def run(self):
        print('the subprocess %s is running' % self.process_name)
        print(os.getpid())
        print(os.getppid())
        time.sleep(3)
        print('the subprocess %s is over' % self.process_name)


if __name__ == '__main__':
    p = MyProcess('mi_chat')
    p.start()
    print('主程序')
    print(os.getpid())

殭屍程序與孤兒程序

殭屍程序

主程序預設需要等待子程序結束才會結束，所有的子程序在執行結束之後都會變成殭屍程序
殭屍程序保留著pid和一些執行過程記錄方便主程序檢視，這些資訊會被主程序回收

孤兒程序

子程序存活著,父程序意外死亡，子程序會被作業系統自動接管

守護程序

from multiprocessing import Process
import time


def task(process_name):
    print(f'子程序:{process_name}執行')
    time.sleep(2)
    print(f'子程序:{process_name}結束執行')


if __name__ == '__main__':
    p = Process(target=task, args=('qq_zone',))
    p.daemon = True
    p.start()
    print('process qq is over')

互斥鎖