進程，互斥鎖，生產者消費者，線程

時間  2019-12-09
標籤 進程 互斥 生產者 消費者 線程 简体版
原文   原文鏈接

進程，互斥鎖，生產者消費者，線程

1、殭屍進程與孤兒進程

  • 代碼演示
'''
殭屍進程（有壞處）：
    - 在子進程結束後，主進程沒有正常結束，子進程的PID不會被回收。

    缺點：
        - 操做系統中PID號是有限的，好比子進程PID號沒法正常回收，則會佔用PID號。
        - 資源浪費
        - 若PID號滿了，則沒法建立新的進程。

孤兒進程（沒有壞處）：

    - 在子進程沒有結束時，主進程沒有「正常結束」，子進程PID不會被回收。
    - 操做系統優化機制（孤兒院）：
        當主進程意外終止，操做系統會檢測是否有正在運行的子進程，會將他們放入孤兒院，讓操做系統幫你自動回收。

'''
#孤兒院進程
from multiprocessing import Process
from multiprocessing import current_process
#在子進程中調用，能夠拿到子進程對象.pid能夠獲取pid號
#在主進程中調用，能夠拿到主進程對象.pid能夠獲取pid號
import os
import time


def task():
    print(f'start...{current_process().pid}')
    time.sleep(1000)
    print(f'end...{os.getpid()}')
    print('子進程結束啦啊...')

if __name__ == '__main__':
    p = Process(target=task)

    p.start()

    print(f'進入主進程的io--->{current_process().pid}')
    time.sleep(4)
    print(f'進入主進程的io--->{os.getpid()}')

    #主進程結束
    print('主進程結束...')
    print(f'查看主進程{os.getpid()}')
    f = open('yafenghandsome.txt')#此時主進程沒有正常結束


#殭屍進程
from multiprocessing import Process
from multiprocessing import current_process
#在子進程中調用，能夠拿到子進程對象.pid能夠獲取pid號
#在主進程中調用，能夠拿到主進程對象.pid能夠獲取pid號
import os
import time
def task():
    print(f'start...{current_process().pid}')
    time.sleep(1)
    print(f'end...{os.getpid()}')
    print('子進程結束啦啦...~~~')

if __name__ == '__main__':
    p = Process(target=task)

    p.start()

    print(f'進入主進程的io--->{current_process().pid}')
    time.sleep(5)
    print(f'進入主進程的io--->{os.getpid()}')

    print('主進程結束...')
    print(f'查看主主進程{os.getppid()}')
    f = open('yafeng6666.txt')

2、子進程回收的兩種方式

  • 代碼演示
from multiprocessing import Process
import time

# def task():
#     print('start...')
#     time.sleep(2)
#     print('end...')
#
#
#
# #方式一join讓主進程等待子進程結束，並回收子進程資源，主進程再結束並回收資源。
# if __name__ == '__main__':
#     p = Process(target=task)
#
#     #告訴操做系統幫你開啓子進程
#     p.start()
#     p.join()
#
#     time.sleep(3)
#
#     #主進程結束
#     print('主進程結束...')


# 方式二主進程 「正常結束」 ，子進程與主進程一併被回收資源。

def task():
    print('start...')
    time.sleep(2)
    print('end...')


if __name__ == '__main__':
    p = Process(target=task)
    p.start()

    time.sleep(1)
    print('主進程結束...')

3、進程守護

  • 演示
'''
       守護進程:
            當主進程結束時，子進程也必須結束，並回收。
'''

from multiprocessing import Process

import time


def demo(name):
    print(f'start....{name}')
    time.sleep(100)
    print(f'end...{name}')
    print('子進程結束啦啊....')


if __name__ == '__main__':
    p = Process(target=demo, args=('童子軍Jason1號',))

    # 守護進程必須在p.start（）調用以前設置
    p.daemon = True  # 將子進程p設置爲守護進程

    p.start()

    time.sleep(1)
    print('皇帝駕崩啦...')

4、進程間數據是隔離的

  • 演示
from multiprocessing import Process
import time
'''
進程間數據是隔離的
'''

number = 10

def func():
    global number
    print('子進程1號')
    number = 100


def func2(number):
    print('子進程2號')
    number += 100


if __name__ == '__main__':
    p_obj = Process(target=func)
    p_obj2 = Process(target=func2, args=(number, ))

    p_obj.start()
    p_obj2.start()

    p_obj.join()
    p_obj2.join()
    time.sleep(1)

    print(f'主進程,{number}') #110  ---> 證實進程間數據不是隔離的
                  #10   ---> 證實進程間數據是隔離的

# 子進程1號
# 子進程2號
# 主進程,10

5、進程互斥鎖

  • 演示
from multiprocessing import Process
from multiprocessing import Lock
import random
import time
import json

#搶票例子

#一、查看餘票
def search(name):
    #一、讀取data.json文件中的數據
    with open('data.json', 'r', encoding='utf-8') as f:
        data_dic = json.load(f)
        print(f'用戶{name}查看餘票，餘票還剩：{data_dic.get("number")}!')


#二、如有餘票，購買成功，票數會減小
def buy(name):

    with open('data.json', 'r', encoding='utf-8') as f:
        data_dic = json.load(f)


    #誰先進入這一步表明最早搶到票
    if data_dic.get('number') > 0:
        data_dic['number'] -= 1
        time.sleep(random.randint(1, 3))

        with open('data.json', 'w', encoding='utf-8') as f:
            json.dump(data_dic, f)

        print(f'用戶{name}, 搶票成功！')

    else:
        print(f'用戶{name}, 搶票失敗！')


def run(name, lock):
    #假設1000個用戶過來均可以立馬查看餘票
    search(name)

    lock.acquire()  #加鎖
    buy(name)
    lock.release()  #釋放鎖


if __name__ == '__main__':
    lock = Lock()

    #開啓多進程，實現併發
    for line in range(10):
        p_obj = Process(target=run, args=(f'jason{line}', lock))
        p_obj.start()


# 用戶jason2查看餘票，餘票還剩：1!
# 用戶jason0查看餘票，餘票還剩：1!
# 用戶jason3查看餘票，餘票還剩：1!
# 用戶jason4查看餘票，餘票還剩：1!
# 用戶jason1查看餘票，餘票還剩：1!
# 用戶jason5查看餘票，餘票還剩：1!
# 用戶jason6查看餘票，餘票還剩：1!
# 用戶jason7查看餘票，餘票還剩：1!
# 用戶jason8查看餘票，餘票還剩：1!
# 用戶jason2, 搶票成功！
# 用戶jason0, 搶票失敗！
# 用戶jason3, 搶票失敗！
# 用戶jason4, 搶票失敗！
# 用戶jason1, 搶票失敗！
# 用戶jason5, 搶票失敗！
# 用戶jason6, 搶票失敗！
# 用戶jason7, 搶票失敗！
# 用戶jason8, 搶票失敗！
# 用戶jason9查看餘票，餘票還剩：0!
# 用戶jason9, 搶票失敗！

6、隊列

  • 演示
from multiprocessing import Queue #multiprocessing 提供隊列，先進先出
from multiprocessing import JoinableQueue  #JoinableQueue提供隊列，先進先出
import queue

#第一種
# q_obj1 = Queue(5)  #此處的5指的是隊列中只能存放5份數據
#
# #添加數據到隊列中
# q_obj1.put('熱巴！')
# print('添加1個啦')
# q_obj1.put('胡歌！')
# print('添加2個啦')
# q_obj1.put('亞峯！')
# print('添加3個啦')
# q_obj1.put('科比！')
# print('添加4個啦')
# q_obj1.put('詹姆斯！')
# print('添加5個啦')

# #注意：put只要隊列滿了，會進入阻塞狀態
# q_obj1.put('sean')
# print('我想添加第六個看會不會報錯')

#put_nowait:只要隊列滿了就會報錯
# q_obj1.put_nowait('sean')


# 添加1個啦
# 添加2個啦
# 添加3個啦
# 添加4個啦
# 添加5個啦
# queue.Full


#get：只要隊列中有數據，就能獲取數據，若沒有會進入阻塞狀態


# print(q_obj1.get())
# print(q_obj1.get())
# print(q_obj1.get())
# print(q_obj1.get())
# print(q_obj1.get())


#get_nowait:若隊列中沒有數據獲取則會報錯
# print(q_obj1.get_nowait())

# 熱巴！
# 胡歌！
# 亞峯！
# 科比！
# 詹姆斯！
# _queue.Empty


# #第二種方式
# q_obj1 = JoinableQueue(5)  #此處的5指的是隊列中只能存放5份數據
# #添加數據到隊列中
# q_obj1.put('熱巴！')
# print('添加1個啦')
# q_obj1.put('胡歌！')
# print('添加2個啦')
# q_obj1.put('亞峯！')
# print('添加3個啦')
# q_obj1.put('科比！')
# print('添加4個啦')
# q_obj1.put('詹姆斯！')
# print('添加5個啦')
#
# # #注意：put只要隊列滿了，會進入阻塞狀態
# # q_obj1.put('sean')
# # print('我想添加第六個看會不會報錯')
#
# # put_nowait:只要隊列滿了就會報錯
# # q_obj1.put_nowait('sean')
#
#
# # 添加1個啦
# # 添加2個啦
# # 添加3個啦
# # 添加4個啦
# # 添加5個啦
# # queue.Full
#
#
# # get：只要隊列中有數據，就能獲取數據，若沒有會進入阻塞狀態
#
#
# print(q_obj1.get())
# print(q_obj1.get())
# print(q_obj1.get())
# print(q_obj1.get())
# print(q_obj1.get())
#
#
# # get_nowait:若隊列中沒有數據獲取則會報錯
# # print(q_obj1.get_nowait())
# #
# # 熱巴！
# # 胡歌！
# # 亞峯！
# # 科比！
# # 詹姆斯！
# # _queue.Empty


# 第三種方式
q_obj1 = queue.Queue(5)  #此處的5指的是隊列中只能存放5份數據

#添加數據到隊列中
q_obj1.put('熱巴！')
print('添加1個啦')
q_obj1.put('胡歌！')
print('添加2個啦')
q_obj1.put('亞峯！')
print('添加3個啦')
q_obj1.put('科比！')
print('添加4個啦')
q_obj1.put('詹姆斯！')
print('添加5個啦')

#注意：put只要隊列滿了，會進入阻塞狀態
#q_obj1.put('sean')
#print('我想添加第六個看會不會報錯')

# put_nowait:只要隊列滿了就會報錯
#q_obj1.put_nowait('sean')


# 添加1個啦
# 添加2個啦
# 添加3個啦
# 添加4個啦
# 添加5個啦
# queue.Full


#get：只要隊列中有數據，就能獲取數據，若沒有會進入阻塞狀態


print(q_obj1.get())
print(q_obj1.get())
print(q_obj1.get())
print(q_obj1.get())
print(q_obj1.get())


#get_nowait:若隊列中沒有數據獲取則會報錯
#print(q_obj1.get_nowait())

# 熱巴！
# 胡歌！
# 亞峯！
# 科比！
# 詹姆斯！
# _queue.Empty

7、IPC（進程間通訊）

  • 演示
from multiprocessing import Process
from multiprocessing import JoinableQueue
import time

'''
經過隊列可實現進程間通訊
'''

def task1(q):
    x = 100
    q.put(x)
    print('添加數據')

    time.sleep(3)
    print(q.get())


def task2(q):
    #想要在task2中獲取task1中的x
    res = q.get()
    print(f'獲取的數據{res}')
    q.put(9527)


if __name__ == '__main__':
    q = JoinableQueue(10)

    #產生兩個不一樣的子進程
    p1 = Process(target=task1, args=(q, ))
    p2 = Process(target=task2, args=(q, ))

    p1.start()
    p2.start()


# 添加數據
# 獲取的數據100
# 9527

8、生產者與消費者

  • 演示
from multiprocessing import JoinableQueue
from multiprocessing import Process
import time

#生產者：生產數據---> 隊列
def producer(name, food, q):
    msg = f'{name}生產了{food}食物'

    #生產一個食物添加到牌隊列中去
    q.put(food)
    print(msg)


#消費者： 使用數據 <--- 隊列
def customer(name, q):
    while True:
        try:
            time.sleep(0.5)

            #若報錯，則跳出循環
            food = q.get_nowait()
            msg = f'{name}吃了{food}食物'
            print(msg)

        except Exception:
            break

if __name__ == '__main__':
    q = JoinableQueue()

    #建立10個生產者
    for line in range(10):
        p1 = Process(target=producer, args=('yafeng', f'高級食物{line}', q))
        p1.start()


    #建立兩個消費者
    c1 = Process(target=customer, args=('jason', q))
    c2 = Process(target=customer, args=('sean', q))
    c1.start()
    c2.start()

# yafeng生產了高級食物1食物
# yafeng生產了高級食物0食物
# yafeng生產了高級食物2食物
# yafeng生產了高級食物3食物
# yafeng生產了高級食物4食物
# yafeng生產了高級食物5食物
# yafeng生產了高級食物6食物
# yafeng生產了高級食物8食物
# yafeng生產了高級食物7食物
# yafeng生產了高級食物9食物
# jason吃了高級食物1食物
# sean吃了高級食物0食物
# jason吃了高級食物2食物
# sean吃了高級食物3食物
# jason吃了高級食物4食物
# sean吃了高級食物5食物
# jason吃了高級食物6食物
# sean吃了高級食物8食物
# jason吃了高級食物7食物
# sean吃了高級食物9食物

9、線程以及守護線程

  • 開啓線程的方式以及理論知識
'''
線程：
    一、什麼是線程？
        進程：資源單位
        線程：執行單位

        線程與進程都是虛擬的概念，爲了更好表達某種食物

        注意:開啓一個進程，必定會自帶一個線程，線程纔是真正的執行者。

    二、爲何要使用線程？
        節省資源的佔用

        - 開啓進程：
            -1）會產生一個內存空間，申請一塊子資源
            -2) 會自帶一個主線程
            -3）開啓子進程的速度要比開啓子線程的速度慢

        - 開啓線程
            -1）；一個進程內能夠開啓多個線程，從進程的內存空間中申請執行單位
            -2）：節省資源

        - 開啓三個線程
            - 從一個內存資源中，申請三個小的執行單位

        - IO密集型用：多線程
            - IO（時間由用戶定）：
                - 阻塞：切換 + 保存狀態

        - 計算密集型用：多進程
            - 計算（時間由操做系統定）：
                - 計算時間很長 ---> 切換 + 保存狀態

    注意：進程與進程之間數據是隔離的，線程與線程之間數據是共享的

    三、怎麼使用線程？
    from threading import Thread

'''
from threading import Thread
import time

number = 1000


# #啓動線程的方式一：
# def task():
#     global number
#     number = 100
#     print('start...')
#     time.sleep(1)
#     print('end...')
#
#
# if __name__ == '__main__':
#     #開啓一個子線程
#     t = Thread(target=task)
#     t.start()
#
#     t.join()
#     print('主進程（主線程）...')
#     print(number)
#
# # 主進程（主線程）...
# # 100
# # start...
# # end...


# #開啓線程的方式二：
# class MyThread(Thread):
#     def run(self):
#         print('start...')
#         time.sleep(1)
#         print('end...')
#
#
# if __name__ == '__main__':
#     #開啓一個子線程
#     t = MyThread()
#     t.start()
#     # t.join()
#     print('主進程（主線程）...')
  • 子線程守護
from threading import current_thread

number = 1000

def task():
    global number
    number = 100
    print(f'start....{current_thread().name}')
    time.sleep(3)
    print(f'end....{current_thread().name}')


if __name__ == '__main__':

    for line in range(10):
        t = Thread(target=task)
        #加上守護線程：主進程結束，表明主線程也結束，子線程可能未被回收
        t.daemon = True
        t.start()

        print(f'主進程（主線程）....{current_thread().name}')
        print(number)

10、線程互斥鎖

  • 演示
from threading import Lock
from threading import Thread
import time


#開啓10個線程，對一個數據進行修改
number = 100


def task():
    global number

    lock.acquire()
    number2 = number
    time.sleep(1)
    number = number2 - 1
    lock.release()



if __name__ == '__main__':
    lock = Lock()
    list1 = []
    for line in range(10):
        t = Thread(target=task)
        t.start()
        list1.append(t)

    for t in list1:
        t.join()

    print(number)

#>>>> 90
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程