day37 进程，守护，互斥锁，进程队列

最新推荐文章于 2024-03-05 13:56:03 发布
最新推荐文章于 2024-03-05 13:56:03 发布
阅读量156 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinlingjishu/article/details/108249222
版权

目录

1 创建进程的两种方式

第一种

from multiprocessing import Process
import time


def task(n):
    print('我是子进程')
    time.sleep(n)
    print('子进程结束')


if __name__ == '__main__':
    # args=(), kwargs={}
    # t=Process(task,args=(1,))
    t = Process(target=task, kwargs={'n': 1})
    t.start()  # 通知操作系统，开启进程，执行task函数
    print('主')

第二种：

from multiprocessing import Process
import time

class Task(Process):
    def __init__(self, n):
        super().__init__()
        self.n = n

    def run(self):
        print('我是子进程')
        time.sleep(self.n)
        print('子进程结束')


if __name__ == '__main__':
    t = Task(1)
    # t.run(1)  # 不是调用t.run(),而是调用t.start()
    t.start()
    print('主')

join的使用

from multiprocessing import Process
import time


def task(n):
    print('我是子进程')
    time.sleep(n)
    print('子进程结束')


if __name__ == '__main__':
    ctime = time.time()
    t = Process(target=task, kwargs={'n': 1})
    t2 = Process(target=task, kwargs={'n': 2})
    t.start()
    t2.start()
    t.join()  # 等待t子进程执行完成
    t2.join()  # 等待t2子进程执行完成
    print('主')
    ctime2 = time.time()
    print(ctime2 - ctime)

进程之间数据隔离

from multiprocessing import Process
import time

age = 18


def task(n):
    global age  # 局部修改全局
    age = 99
    print('我是子进程')
    time.sleep(n)
    print('子进程结束')
    print(age)


if __name__ == '__main__':
    t = Process(target=task, kwargs={'n': 1})
    t.start()
    t.join()  # 等待t子进程执行完成
    print('主')
    print(age) # 数据没有变，主进程中打印age和子进程的age没有半毛钱关系，数据是隔离的

2.进程的其他方法

from multiprocessing import Process,current_process
import time
import os

# 每个进程都会有自己的id号pid


def task():
    print('子进程')

    # 当前进程的id号
    print(current_process().pid)
    print(os.getpid()) # 跟上面打印出来是一模一样的
    # 取出该进程父id号
    print('-----',os.getppid())
    # current_process()当前进程对象

    print(current_process().is_alive())
    time.sleep(2)

    print('子进程结束')


if __name__ == '__main__':
    t = Process(target=task, )
    t.start()
    # t1 = Process(target=task, )
    # t1.start()
    # t.is_alive()  # t这个进程是否存活
    # print('主进程打印的结果',t.is_alive())
    print(t.pid)
    time.sleep(0.5)
    # t.terminate()  # 把t进程关闭
    # time.sleep(0.1)
    print('主进程打印的结果', t.is_alive())

守护进程

from multiprocessing import Process, current_process
import time
import os


def task():
    # print(os.getpid())
    print('子进程')
    time.sleep(200)
    print('子进程结束')


if __name__ == '__main__':
    t = Process(target=task, )
    # 守护进程：主进程一旦结束，子进程也结束
    # t.daemon=True  # 一定要加在启动之前
    t.start()

    time.sleep(1)
    print('主进程结束')
    print(os.getppid())
    time.sleep(100)


# 问题1 ：主进程的父进程是谁？就是pycharm
# 问题2 ：主进程开了很多子进程，每个都需要设置守护吗？看你的需求，你想让某个进程是守护：t.daemon=True

3.互斥锁

from multiprocessing import Process, Lock
import json
import time
import random


def search():
    # 查票的函数
    # 打开文件，读出ticket_count
    with open('ticket', 'r', encoding='utf-8') as f:
        dic = json.load(f)
        print('余票还有：', dic.get('ticket_count'))


def buy():
    with open('ticket', 'r', encoding='utf-8') as f:
        dic = json.load(f)

    time.sleep(random.randint(1, 3))  # 模拟一下网络延迟
    if dic.get('ticket_count') > 0:
        # 能够买票
        dic['ticket_count'] -= 1
        # 保存到文件中去
        with open('ticket', 'w', encoding='utf-8') as f:
            json.dump(dic, f)
            print('买票成功')
    else:
        # 买票失败
        print('买票失败')

写一个函数，先查票，再买票

def task(mutex):
    search()
    # 买票过程要加锁
    # 买前加锁
    # mutex.acquire()
    # buy()  # 10个进程变成了串行执行
    # # 买后释放锁
    # mutex.release()
    with mutex:
        buy()


if __name__ == '__main__':
    # 锁的创建，在哪？主进程创建锁
    mutex = Lock()  # 创建一把锁
    # 模拟十个人买票(开10个进程)
    for i in range(10):
        t = Process(target=task, args=(mutex,))
        t.start()

面向对象高级：魔法方法（__开头的），enter__和__exit,上下文管理器
自己写一个类，实现类似于打开文件 with open 的功能
with MyClass(‘文件名’,‘方式’，‘编码’) as f:
f.read()

在这写代码，f就关闭了

class MyClass():
    def __init__(self,file_name,mode,encoding):
        self.file_name=file_name
        self.mode=mode
        self.encoding=encoding

    def __enter__(self):
        print('只要有with，就会执行我')
        self.file=open(self.file_name,self.mode,encoding=self.encoding)

        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 只要顶格写代码，就会执行我
        print('只要顶格写代码，就会执行我')
        self.file.close()


with MyClass('ticket','r','utf-8') as f:
    print(f.read())
    print('xxss')
    print("sdfadasf")


# a=MyClass('ticket','r','utf-8')

4.队列

from multiprocessing import Queue

# 实例化得到要给对象

q=Queue(5)  # 默认很大，可以放很多，写了个5，只能放5个

# 往管道中放值
q.put(1)
q.put('lqz')
q.put(18)
q.put(19)
# q.put(20)
# q.put(21)
# q.put_nowait(100)

# 从管道中取值
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get(timeout=100))  # 等0.1s还没有值，就结束
# print(q.get_nowait())        # 不等了，有就是有，没有就没有

print(q.empty())  # 看一下队列是不是空的
print(q.full())   # 看一下队列是不是满的


# 总结：
'''
q=Queue(队列大小)
# 放值
q.put(asdf)
q.put_nowait(asdf)  # 队列满了，放不进去就不放了，报错

# 取值
q.get()  # 从队列头部取出一个值
q.get_nowait() # 从队列头部取值，没有就抛错


# 队列是否为空，是否满
print(q.empty())  # 看一下队列是不是空的
print(q.full())   # 看一下队列是不是满的
'''

5.进程间通信

from multiprocessing import Process, current_process, Queue
import time
import os


def task1(q):
    print('我是task1进程，我的id号是：%s'%os.getpid())
    q.put('lqz is handsome')


def task2(q):

    # res=q.get()
    # print('我是task2进程，我的id号是：%s'%os.getpid(),res)
    print('我是task2进程，我的id号是：%s'%os.getpid())


if __name__ == '__main__':
    q = Queue(5)

    t1 = Process(target=task1, args=(q,))
    t1.start()
    t2 = Process(target=task2, args=(q,))
    t2.start()

    print(q.get())

1 并发编程总体课程

操作系统发展史（了解）
多道技术（了解）
进程调度（讲）
进程三状态（就绪，阻塞，运行）
同步异步 阻塞非阻塞：异步+非阻塞
创建进程的两种方式(重点)
join方法
进程间数据相互隔离
僵尸进程与孤儿进程
进程对象及其他方法
守护进程
互斥锁
队列介绍
IPC机制
生产者消费者模型
线程理论
开启线程的两种方式
TCP服务端实现并发效果
线程对象join方法
同一个进程下的多个线程
线程对象及其他方法
线程互斥锁
GIL全局解释器锁理论
GIP与普通互斥锁的区别
多线程与多进程比较
死锁现象
递归锁
信号量
Event事件
线程q
池的概念
线程池
进程池
协程基本原理
gevent模块
协程实现tcp并发
io模型介绍
阻塞io模型
非阻塞io模型理论
非阻塞io模型代码演示
io多路复用
asyncio模块
io模型

2 内容回顾

2.1 操作系统发展史

https://www.cnblogs.com/xiaoyuanqujing/articles/11715635.html

2.2 多道技术（了解）

https://www.cnblogs.com/xiaoyuanqujing/articles/11715646.html

2.4 同步异步 阻塞非阻塞

-flask，django3.0以前，都是同步框架
-tornado，sanic，fastAPI 异步框架

2.5 创建进程的两种方式(重点)

### 1 创建进程的两种方式

# 第一种
# from multiprocessing import Process
# import time
#
#
# def task(n):
#     print('我是子进程')
#     time.sleep(n)
#     print('子进程结束')
#
#
# if __name__ == '__main__':
#     # args=(), kwargs={}
#     # t=Process(task,args=(1,))
#     t = Process(target=task, kwargs={'n': 1})
#     t.start()  # 通知操作系统，开启进程，执行task函数
#     print('主')

# 第二种：
# from multiprocessing import Process
# import time
#
# class Task(Process):
#     def __init__(self, n):
#         super().__init__()
#         self.n = n
#
#     def run(self):
#         print('我是子进程')
#         time.sleep(self.n)
#         print('子进程结束')
#
#
# if __name__ == '__main__':
#     t = Task(1)
#     # t.run(1)  # 不是调用t.run(),而是调用t.start()
#     t.start()
#     print('主')

2.6 join方法

# join的使用:等待子进程执行完成
# from multiprocessing import Process
# import time
#
#
# def task(n):
#     print('我是子进程')
#     time.sleep(n)
#     print('子进程结束')
#
#
# if __name__ == '__main__':
#     ctime = time.time()
#     t = Process(target=task, kwargs={'n': 1})
#     t2 = Process(target=task, kwargs={'n': 2})
#     t.start()
#     t2.start()
#     t.join()  # 等待t子进程执行完成
#     t2.join()  # 等待t2子进程执行完成
#     print('主')
#     ctime2 = time.time()
#     print(ctime2 - ctime)

2.7 进程间数据相互隔离

# 进程之间数据隔离
from multiprocessing import Process
import time

age = 18


def task(n):
    global age  # 局部修改全局
    age = 99
    print('我是子进程')
    time.sleep(n)
    print('子进程结束')
    print(age)


if __name__ == '__main__':
    t = Process(target=task, kwargs={'n': 1})
    t.start()
    t.join()  # 等待t子进程执行完成
    print('主')
    print(age) # 数据没有变，主进程中打印age和子进程的age没有半毛钱关系，数据是隔离的

3 今日内容

3.1 进程调度

# 1 先来先服务
# 2 短作业优先
# 3 时间片轮转
# 4 多级反馈队列

易语言

3.2 僵尸进程与孤儿进程

#1 僵尸进程：进程结束了，资源还没来得及回收
#2 孤儿进程：主进程挂了，子进程还没结束，它就会被专门的进程接管

3.3 进程对象及其他方法

# 1 windows:tasklist |findstr 进程id号
# 2 mac，Linux：ps aux | grep 进程id号
# 3 进程对象：t=Process(target=task, )或者是在进程内部：current_process()
# 4 t.pid或者current_process().pid   获取进程id号
# 5 os.getpid() 同上，获取进程id号
# 6 os.getppid() 获取父进程id号，子进程中获取父进程id，等于父进程的id号
# 7 t.is_alive()或者current_process().is_alive()  查看进程是否存活
# 8 t.terminate() 关闭进程，在主进程关闭

3.4 守护进程


from multiprocessing import Process,current_process
import time
import os

def task():
    print(os.getpid())
    print('子进程')
    time.sleep(200)
    print('子进程结束')


if __name__ == '__main__':
    t = Process(target=task, )
    # 守护进程：主进程一旦结束，子进程也结束
    # t.daemon=True  # 一定要加在启动之前
    t.start()


    time.sleep(1)
    print('主进程结束')

3.5 互斥锁

# 同时只有一个人能拿到，必须释放，其他人才能再次获取到

from multiprocessing import Process, Lock
import json
import time
import random


def search():
    # 查票的函数
    # 打开文件，读出ticket_count
    with open('ticket', 'r', encoding='utf-8') as f:
        dic = json.load(f)
        print('余票还有：', dic.get('ticket_count'))


def buy():
    with open('ticket', 'r', encoding='utf-8') as f:
        dic = json.load(f)

    time.sleep(random.randint(1, 3))  # 模拟一下网络延迟
    if dic.get('ticket_count') > 0:
        # 能够买票
        dic['ticket_count'] -= 1
        # 保存到文件中去
        with open('ticket', 'w', encoding='utf-8') as f:
            json.dump(dic, f)
            print('买票成功')
    else:
        # 买票失败
        print('买票失败')


# 写一个函数，先查票，再买票

def task(mutex):
    search()
    # 买票过程要加锁
    # 买前加锁
    # mutex.acquire()
    # buy()  # 10个进程变成了串行执行
    # # 买后释放锁
    # mutex.release()
    with mutex:
        buy()


if __name__ == '__main__':
    # 锁的创建，在哪？主进程创建锁
    mutex = Lock()  # 创建一把锁
    # 模拟十个人买票(开10个进程)
    for i in range(10):
        t = Process(target=task, args=(mutex,))
        t.start()

3.6 队列介绍



from multiprocessing import Queue

# 实例化得到要给对象

q=Queue(5)  # 默认很大，可以放很多，写了个5，只能放5个

# 往管道中放值
q.put(1)
q.put('lqz')
q.put(18)
q.put(19)
# q.put(20)
# q.put(21)
# q.put_nowait(100)

# 从管道中取值
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get(timeout=100))  # 等0.1s还没有值，就结束
# print(q.get_nowait())        # 不等了，有就是有，没有就没有

print(q.empty())  # 看一下队列是不是空的
print(q.full())   # 看一下队列是不是满的


# 总结：
'''
q=Queue(队列大小)
# 放值
q.put(asdf)
q.put_nowait(asdf)  # 队列满了，放不进去就不放了，报错

# 取值
q.get()  # 从队列头部取出一个值
q.get_nowait() # 从队列头部取值，没有就抛错


# 队列是否为空，是否满
print(q.empty())  # 看一下队列是不是空的
print(q.full())   # 看一下队列是不是满的
'''

3.7 IPC机制（进程间通信）

# Inter-Process Communication，进程间通信
from multiprocessing import Process, current_process, Queue
import time
import os


def task1(q):
    print('我是task1进程，我的id号是：%s'%os.getpid())
    q.put('lqz is handsome')


def task2(q):

    # res=q.get()
    # print('我是task2进程，我的id号是：%s'%os.getpid(),res)
    print('我是task2进程，我的id号是：%s'%os.getpid())


if __name__ == '__main__':
    q = Queue(5)

    t1 = Process(target=task1, args=(q,))
    t1.start()
    t2 = Process(target=task2, args=(q,))
    t2.start()

    print(q.get())
技术承
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python-多线程-守护线程-线程互斥锁-信号量-守护进程的使用
zdc45625的博客
01-02 482
文章目录一、多线程二、线程对比进程三、线程间资源共享四、守护线程五、线程中常用属性六、线程互斥锁七、信号量八、守护进程的使用 一、多线程 什么是线程：程序的执行线路，相当于与一条流水线，其包含了程序的具体执行步骤，如果我们把操作系统比喻为一个工厂，进程就是车间，线程就是流水线 线程和进程的关系：进程中包含了运行改程序需要所有资源，进程是一个资源单位，线程是CPU的最小执行单位，每一个进程一...
易语言线程互斥对象解决
12-08
易语言 线程池 多线程 线程互斥 易语言线程互斥的解决办法
Python中的 进程问题详解。守护进程，互斥锁，队列,IPC等介绍
零基础学习Python的博客
08-24 189
口说不如身逢，耳闻不如目见。 嘴上说不如亲身做，耳听为虚，一定要亲眼看到。 1 进程调度 # 1 先来先服务 # 2 短作业优先 # 3 时间片轮转 # 4 多级反馈队列 # 易语言 2 僵尸进程与孤儿进程 #1 僵尸进程：进程结束了，资源还没来得及回收 #2 孤儿进程：主进程挂了，子进程还没结束，它就会被专门的进程接管 3 进程对象及其他方法 # 1 windows:tasklist |findstr 进程id号 # 2 mac，Linux：ps aux | grep 进程id号 # 3 进程对象：t
e语言-易语言线程安全之原子锁与读写锁
08-23
.版本 2 .支持库 spec .子程序 _临时子程序 .局部变量 ai, AtomicInteger .局部变量 rwLock, ReadWriteLock ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。 调试输出 (ai.Get ()) 调试输出 (ai.IncrementAndGet ()) 调试输出 (ai.Get ()) rwLock.AcquireReadLock () 调试输出 (“获得读取锁...”) rwLock.ReleaseReadLock () rwLock.AcquireWriteLock () 调试输出 (“获得写入锁...”) rwLock.ReleaseWriteLock ()
线程同步方式
最新发布
m0_65443540的博客
03-05 253
线程同步是指协调多个线程的执行顺序以及访问共享资源的方式，以避免出现竞争条件（Race Condition）和数据不一致性等问题。- 互斥锁是最常用的线程同步机制之一，通过对共享资源加锁来确保同时只有一个线程可以访问共享资源。- 信号量是一种更广泛的线程同步工具，除了互斥作用外，还可以控制多个线程同时访问共享资源的数量。- 信号量可以是计数信号量（允许多个线程同时访问）或二进制信号量（只允许一个线程访问）。- 通常与互斥锁一起使用，等待线程在检查条件时会释放锁，当条件满足时，唤醒等待线程。
线程基础之多线程之间通讯
StayKib的博客
05-27 368
一、 目标 多线程之间如何通讯 wait、notify、notifyAll()方法 lock 停止线程 守护线程 Join方法 优先级 Yield #多线程之间如何实现通讯 # 什么是多线程之间通讯？ 多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。 多线程之间通讯需求 需求:第一个线程写入(input)用户，另一个线程取读取(out)用户.实现读一个，写一个操作。 /** * @ Author : 冯旭 * @ Description : 共享实体 *
Day 34 进程调度,守护进程，互斥锁
A1L__的博客
08-24 246
Day 34 一、进程调度 # 1 先来先服务 # 2 短作业优先 # 3 时间片轮转 # 4 多级反馈队列 二、进程间数据相互隔离 验证数据隔离 如果主进程中x的值是否改变,没有改变则说明父进程与子进程之间数据隔离 为什么进程之间数据不能共享. 开启两个程序 一个QQ,一个微信, 开启了两个进程.如果进程之间可以通信, 那QQ的进程是不是可以任意访问微信的数据. 这样会造成诸多问题. 所以,进程间理论上是不能通信的. 但是可以借助中间代理(队列) from multiprocessing import
day35 守护进程、互斥锁、IPC
weixin_30402343的博客
06-03 65
day35 守护进程、互斥锁、IPC 1、守护进程 # 守护进程：当父进程执行完毕后，设置的守护进程也会跟着结束# 当一个进程被设置为守护进程后，其不能再产生子进程​ from multiprocessing import Process import time ​ def test(): print("妃子入宫了") time.sleep(5) ...
进程 join方法 Queue 守护进程 互斥锁
Tao.的博客
08-09 676
进程
进程线程互斥同步方法
02-28
进程，线程同步互斥的控制方法，详细介绍，个人总结，面试常问
day9 线程与进程、队列
yleave的博客
07-18 165
文章目录1. 进程与线程2. 队列 queue 1. 进程与线程   进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。而负责执行任务则是cpu。   线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 进程与线程的区别： Threads share th...
python多进程与多线程
Z__legend的博客
08-07 637
多任务：同一时间执行多个任务，有并发和并行两种表现形式 并发：在一段时间内交替执行多个任务 并行：在一段时间内真正的同时执行多个任务 多进程 进程（Process）是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位；通俗理解：一个正在运行的程序就是一个进程。 多进程的作用，如下图： 多进程的创建 这里使用的是跨平台的多进程模块multiprocessing 导入进程包 import multiprocessing import time def sing(num, name):
python开发之线程与进程
冠军阿狗的博客
03-31 1008
python开发之线程与进程一、线程与进程1. 线程（thread）2. 进程（process）3. 进程与线程的区别4. Python GIL(Global Interpreter Lock 全局解释器锁)二、threading模块1. 线程的两种调用方式2. Join & Daemon三、锁1. 同步锁(Lock)同步锁与GIL的关系？2. 线程死锁和递归锁3. 条件变量(Condit...
进程间通信（IPC机制),生产者与消费者模型
Petrus
11-09 495
基于加锁能带来效率低和需要自己手动加锁的问题，我们最好寻找一种解决方案能够兼顾: 1.效率高（多个进程共享一块内存的数据） 2.帮我们处理好锁的问题，这就是multiprocessing模块为我们提供的基于消息的IPC通信机制:队列和管道。 3.队列和管道都是将数据存放于内存中 4.队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来， 我们应该尽量避免使用共享数据，尽可能使...
多线程(互斥锁、读写锁、条件变量、信号量、自旋锁)相关
sky234537667的专栏
01-06 2424
1.互斥锁--保护了一个临界区，在这个临界区中，一次最多只能进入一个线程。如果有多个进程在同一个临界区内活动，就有可能产生竞态条件(race condition)导致错误，其中包含递归锁和非递归锁，（递归锁：同一个线程可以多次获得该锁，别的线程必须等该线程释放所有次数的锁才可以获得）。 2.读写锁--从广义的逻辑上讲，也可以认为是一种共享版的互斥锁。可以多个线程同时进行读,但是写操作必须单独进行,不可多写和边读边写。如果对一个临界区大部分是读操作而只有少量的写操作，读写锁在一定程度上能够降低线程互斥产生
多线程与并发----线程互斥技术
pengzhisen123的博客
05-08 464
1、使用synchronized代码块2、使用synchronized方法3、分析静态方法锁使用的同步监视器对象是什么？4、wait与notify实现线程间的通信例一：使用内部类和两个线程交替不停的打印lisi和zhangsan两个名字public class ThreadSynchronized { public static void main(String[] args) { ...
Linux线程-互斥锁pthread_mutex_t
热门推荐
欣宇的专栏
09-20 14万+
在线程实际运行过程中，我们经常需要多个线程保持同步。这时可以用互斥锁来完成任务；互斥锁的使用过程中，主要有pthread_mutex_init，pthread_mutex_destory，pthread_mutex_lock，pthread_mutex_unlock这几个函数以完成锁的初始化，锁的销毁，上锁和释放锁操作。 一，锁的创建     锁可以被动态或静态创建，可以用宏PTHRE
linux多进程互斥锁
09-20
Linux多进程互斥锁是一种用于保护临界资源的同步机制。在Linux中，可以使用互斥锁来确保在多个进程同时访问临界资源时，只有一个进程可以进入临界区执行操作，其他进程需要等待当前进程释放互斥锁后才能进入。 在Linux中，互斥锁的实现基于pthread库中的mutex。具体来说，可以使用以下函数来实现互斥锁的创建、加锁和释放操作： 1. 创建互斥锁： ``` int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); ``` 2. 加锁互斥锁： ``` int pthread_mutex_lock(pthread_mutex_t *mutex); ``` 3. 解锁互斥锁： ``` int pthread_mutex_unlock(pthread_mutex_t *mutex); ``` 多进程互斥锁的实现需要注意以下几点： - 互斥锁必须在多个进程之间共享，通常将互斥锁存储在共享内存中。 - 进程需要通过共享内存进行通信，以确定哪个进程可以获得互斥锁。 - 在进程之间使用互斥锁时，需要注意对共享内存的操作，以避免竞态条件和死锁等问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值