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

来源: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
  • UOS 開啟 VisualStudio 遠程調試 .NET 應用之旅
    前言 在我們開發過程中基本上不可或缺的用到一些敏感機密數據，比如SQL伺服器的連接串或者是OAuth2的Secret等，這些敏感數據在代碼中是不太安全的，我們不應該在源代碼中存儲密碼和其他的敏感數據，一種推薦的方式是通過Asp.Net Core的機密管理器。 機密管理器 在 ASP.NET Core ...
  • C# - 能否讓 SortedSet.RemoveWhere 內傳入的委托非同步執行
    新改進提供的Taurus Rpc 功能，可以簡化微服務間的調用，同時可以不用再手動輸出模塊名稱，或調用路徑，包括負載均衡，這一切，由框架實現並提供了。新的Taurus Rpc 功能，將使得服務間的調用，更加輕鬆、簡約、高效。 ...
  • 順序棧的介面程式
    順序棧的介面程式 目錄順序棧的介面程式頭文件創建順序棧入棧出棧利用棧將10進位轉16進位數驗證 頭文件 #include <stdio.h> #include <stdbool.h> #include <stdlib.h> 創建順序棧 // 指的是順序棧中的元素的數據類型，用戶可以根據需要進行修改 ...
  • mORMot2 獲取數據集1
    前言 整理這個官方翻譯的系列，原因是網上大部分的 tomcat 版本比較舊，此版本為 v11 最新的版本。 開源項目 從零手寫實現 tomcat minicat 別稱【嗅虎】心有猛虎，輕嗅薔薇。 系列文章 web server apache tomcat11-01-官方文檔入門介紹 web serv ...
  • 萬字長文總結與剖析C語言關鍵字 -- <<C語言深度解剖>>
    C總結與剖析:關鍵字篇 -- <<C語言深度解剖>> 目錄C總結與剖析:關鍵字篇 -- <<C語言深度解剖>>程式的本質:二進位文件變數1.變數:記憶體上的某個位置開闢的空間2.變數的初始化3.為什麼要有變數4.局部變數與全局變數5.變數的大小由類型決定6.任何一個變數,記憶體賦值都是從低地址開始往高地 ...
  • 【Flink入門修煉】2-3 Flink Checkpoint 原理機制
    如果讓你來做一個有狀態流式應用的故障恢復，你會如何來做呢？ 單機和多機會遇到什麼不同的問題？ Flink Checkpoint 是做什麼用的？原理是什麼？ ...
  • C++ 多級繼承與多重繼承：代碼組織與靈活性的平衡
    C++ 多級繼承 多級繼承是一種面向對象編程（OOP）特性，允許一個類從多個基類繼承屬性和方法。它使代碼更易於組織和維護，並促進代碼重用。 多級繼承的語法 在 C++ 中，使用 : 符號來指定繼承關係。多級繼承的語法如下： class DerivedClass : public BaseClass1 ...
  • 圖文結合手把手教你創建SpringCloud項目
    前言 什麼是SpringCloud？ Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的開發便利性簡化了分散式系統的開發，比如服務註冊、服務發現、網關、路由、鏈路追蹤等。Spring Cloud 並不是重覆造輪子，而是將市面上開發得比較好的模塊集成進去，進行封裝，從 ...
  • 類模板的常見用法
    class_template 類模板和函數模板的定義和使用類似，我們已經進行了介紹。有時，有兩個或多個類，其功能是相同的，僅僅是數據類型不同。類模板用於實現類所需數據的類型參數化 template<class NameType, class AgeType> class Person { publi ...
  • system-v IPC共用記憶體通信
    目錄system v IPC簡介共用記憶體需要用到的函數介面shmget函數--獲取對象IDshmat函數--獲得映射空間shmctl函數--釋放資源共用記憶體實現思路註意 system v IPC簡介 消息隊列、共用記憶體和信號量統稱為system v IPC(進程間通信機制)，V是羅馬數字5，是UNI ...
所有分類