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

来源:https://www.cnblogs.com/yafeng666/archive/2019/12/07/12003639.html
-Advertisement-
Play Games

進程，互斥鎖，生產者消費者，線程 一、僵屍進程與孤兒進程 代碼演示 二、子進程回收的兩種方式 代碼演示 三、進程守護 演示 四、進程間數據是隔離的 演示 五、進程互斥鎖 演示 六、隊列 演示 七、IPC（進程間通信） 演示 八、生產者與消費者 演示 子線程守護 十、線程互斥鎖 演示 ...


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

一、僵屍進程與孤兒進程

  • 代碼演示
'''
僵屍進程（有壞處）：
    - 在子進程結束後，主進程沒有正常結束，子進程的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')

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

  • 代碼演示
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('主進程結束...')

三、進程守護

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

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('皇帝駕崩啦...')

四、進程間數據是隔離的

  • 演示
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

五、進程互斥鎖

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

#搶票例子

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


#2、若有餘票，購買成功，票數會減少
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, 搶票失敗！

六、隊列

  • 演示
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

七、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

八、生產者與消費者

  • 演示
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食物

九、線程以及守護線程

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

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

        註意:開啟一個進程，一定會自帶一個線程，線程才是真正的執行者。

    2、為什麼要使用線程？
        節省資源的占用

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

        - 開啟線程
            -1）；一個進程內可以開啟多個線程，從進程的記憶體空間中申請執行單位
            -2）：節省資源

        - 開啟三個線程
            - 從一個記憶體資源中，申請三個小的執行單位

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

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

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

    3、怎麼使用線程？
    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)

十、線程互斥鎖

  • 演示
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

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 【Leetcode 做題學演算法周刊】第五期
    首發於微信公眾號《前端成長記》，寫於 2019.12.06 背景 本文記錄刷題過程中的整個思考過程，以供參考。主要內容涵蓋： 題目分析設想 編寫代碼驗證 查閱他人解法 思考總結 目錄 "100.相同的樹" "101.對稱二叉樹" "104.二叉樹的最大深度" "107.二叉樹的層次遍歷II" "10 ...
  • 學習重構(5)-簡化條件表達式
    1.Decompose Conditional (分解條件表達式)應用場景：你有一個複雜的條件（if-then-else）語句。從if、then、else三個段落中分別提煉出獨立函數。示例：if (date.before(SUMMER_START) || date.after(SUMMER_END) ...
  • 二分法查找（C語言）
    二分法是一種高效的查找方法，其適用於 已經排好序 的數組 基本思路 從數組最中間的數開始查找判斷，若不是需要查找的數字，則比較大小，之後則在從中間分開的兩邊中的一邊從最中間開始查找判斷，以此類推 演算法描述 這裡以升序數組為例，降序數組類似 1. 記錄數組最中間數的下標，將其中的數與要查找的數進行比較 ...
  • 搞Jedis案例出現問題，有大佬幫我看看怎麼解決嗎？先感謝大佬點進來看了---Day31
    今天學了Jedis的相關內容,然後做了一個案例,但是出現了錯誤，然後我百度了一晚上沒有解決，想到看看發個博客能不能有大佬幫我看一下問題出現在哪裡，百度了一晚上有點懵逼。求大佬幫我解決，在這小弟我先萬分感謝大佬們點進來幫我看，感謝大佬們~ 下麵是案例需求： 案例需求： 1. 提供index.html頁 ...
  • 北華大學網路賽題
    D題 1 #include<iostream> 2 #include<map> 3 #include<algorithm> 4 #define int long long 5 using namespace std; 6 7 /*解題思路：題中的乘以10的倍數，只是虛晃，可以不用在意，因為只要保證字 ...
  • python 狀態模式
    什麼是狀態模式？ 指的是對象內部狀態發生改變對象行為也會發生變化。 狀態模式主要解決的是當控制一個對象狀態的條件表達式過於複雜時的情況。把狀態的判斷邏輯轉移到表示不同狀態的一系列類中，可以把複雜的判斷邏輯簡化。 UML類圖 封裝變化 該模式中狀態是變化的，變化部分被做成了抽象類或介面，這讓做的目的就 ...
  • 選擇排序法（C語言）
    基本思路 在每一次的排序中選出最小（或最大）的數，將其放在數組最前端，然後在後面的數中重覆此步驟，最終達到排序的目的. 演算法描述 將存於數組首位數與後面的數依次比較,將其中的較小的數放到數組放到數組首位 將除存於第二位的數視作首位,重覆第一步的操作 以此類推 代碼實現 這裡以從小到大排序為例 演算法分 ...
  • 冒泡排序法（C語言）
    冒泡排序（Bubble Sort） 一種電腦科學領域的較簡單的排序演算法。它重覆地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果順序（如從大到小、首字母從從Z到A）錯誤就把他們交換過來。走訪元素的工作是重覆地進行直到沒有相鄰元素需要交換，也就是說該元素列已經排序完成。 這個演算法的名字由來是因為越 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類