python爬虫知识点：5种线程锁

嗨喽~大家好呀，这里是魔王呐 ❤ ~!

python更多源码/资料/解答/教程等 点击此处跳转文末名片免费获取

线程安全

线程安全是多线程或多进程编程中的一个概念，在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

线程安全的问题最主要还是由线程切换导致的，比如：

一个房间（进程）中有10颗糖（资源），除此之外还有3个小人（1个主线程、2个子线程），当小人A吃了3颗糖后被系统强制进行休息时他认为还剩下7颗糖，而当小人B工作后又吃掉了3颗糖，那么当小人A重新上岗时会认为糖还剩下7颗，但是实际上只有4颗了。

上述例子中线程A和线程B的数据不同步，这就是线程安全问题，它可能导致非常严重的意外情况发生，我们按下面这个示例来进行说明。

下面有一个数值num初始值为0，我们开启2条线程：

  • 线程1对num进行一千万次+1的操作

  • 线程2对num进行一千万次-1的操作

结果可能会令人咋舌，num最后并不是我们所想象的结果0：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import threadingnum = 0def add():global numfor i in range(10_000_000):num += 1def sub():global numfor i in range(10_000_000):num -= 1if __name__ == "__main__":subThread01 = threading.Thread(target=add)subThread02 = threading.Thread(target=sub)subThread01.start()subThread02.start()subThread01.join()subThread02.join()print("num result : %s" % num)# 结果三次采集
# num result : 669214
# num result : -1849179
# num result : -525674

上面这就是一个非常好的案例，想要解决这个问题就必须通过锁来保障线程切换的时机。

需要我们值得留意的是，在Python基本数据类型中list、tuple、dict本身就是属于线程安全的，

所以如果有多个线程对这3种容器做操作时，我们不必考虑线程安全问题。

锁的作用

锁是Python提供给我们能够自行操控线程切换的一种手段，使用锁可以让线程的切换变的有序。

一旦线程的切换变的有序后，各个线程之间对数据的访问、修改就变的可控，所以若要保证线程安全，就必须使用锁。

threading模块中提供了5种最常见的锁，下面是按照功能进行划分：

  1. 同步锁：lock（一次只能放行一个）

  2. 递归锁：rlock（一次只能放行一个）

  3. 条件锁：condition（一次可以放行任意个）

  4. 事件锁：event（一次全部放行）

  5. 信号量锁：semaphore（一次可以放行特定个）

1、Lock() 同步锁

基本介绍

Lock锁的称呼有很多，如：

  • 同步锁

  • 互斥锁

它们是什么意思呢？如下所示：

  • 互斥指的是某一资源同一时刻仅能有一个访问者对其进行访问，具有唯一性和排他性，但是互斥无法限制访问者对资源的访问顺序，即访问是无序的

  • 同步是指在互斥的基础上（大多数情况），通过其他机制实现访问者对资源的有序访问

同步其实已经实现了互斥，是互斥的一种更为复杂的实现，因为它在互斥的基础上实现了有序访问的特点

下面是threading模块与同步锁提供的相关方法：

使用方式

同步锁一次只能放行一个线程，一个被加锁的线程在运行时不会将执行权交出去，只有当该线程被解锁时才会将执行权通过系统调度交由其他线程。

如下所示，使用同步锁解决最上面的问题：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import threadingnum = 0def add():lock.acquire()global numfor i in range(10_000_000):num += 1lock.release()def sub():lock.acquire()global numfor i in range(10_000_000):num -= 1lock.release()if __name__ == "__main__":lock = threading.Lock()subThread01 = threading.Thread(target=add)subThread02 = threading.Thread(target=sub)subThread01.start()subThread02.start()subThread01.join()subThread02.join()print("num result : %s" % num)# 结果三次采集
# num result : 0
# num result : 0
# num result : 0

这样这个代码就完全变成了串行的状态，对于这种计算密集型I/O业务来说，还不如直接使用串行化单线程执行来得快，所以这个例子仅作为一个示例，不能概述锁真正的用途。

死锁现象

对于同步锁来说，一次acquire()必须对应一次release()，不能出现连续重复使用多次acquire()后再重复使用多次release()的操作，这样会引起死锁造成程序的阻塞，完全不动了，如下所示：

import threadingnum = 0def add():lock.acquire()  # 上锁lock.acquire()  # 死锁# 不执行global numfor i in range(10_000_000):num += 1lock.release()lock.release()def sub():lock.acquire()  # 上锁lock.acquire()  # 死锁# 不执行global numfor i in range(10_000_000):num -= 1lock.release()lock.release()if __name__ == "__main__":lock = threading.Lock()subThread01 = threading.Thread(target=add)subThread02 = threading.Thread(target=sub)subThread01.start()subThread02.start()subThread01.join()subThread02.join()print("num result : %s" % num)
with语句

由于threading.Lock()对象中实现了enter__()与__exit()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import threadingnum = 0def add():with lock:# 自动加锁global numfor i in range(10_000_000):num += 1# 自动解锁def sub():with lock:# 自动加锁global numfor i in range(10_000_000):num -= 1# 自动解锁if __name__ == "__main__":lock = threading.Lock()subThread01 = threading.Thread(target=add)subThread02 = threading.Thread(target=sub)subThread01.start()subThread02.start()subThread01.join()subThread02.join()print("num result : %s" % num)# 结果三次采集
# num result : 0
# num result : 0
# num result : 0

2、RLock() 递归锁

基本介绍

递归锁是同步锁的一个升级版本，在同步锁的基础上可以做到连续重复使用多次acquire()后再重复使用多次release()的操作，但是一定要注意加锁次数和解锁次数必须一致，否则也将引发死锁现象。

下面是threading模块与递归锁提供的相关方法：

使用方式

以下是递归锁的简单使用，下面这段操作如果使用同步锁则会发生死锁现象，但是递归锁不会：

import threadingnum = 0def add():lock.acquire()lock.acquire()global numfor i in range(10_000_000):num += 1lock.release()lock.release()def sub():lock.acquire()lock.acquire()global numfor i in range(10_000_000):num -= 1lock.release()lock.release()if __name__ == "__main__":lock = threading.RLock()subThread01 = threading.Thread(target=add)subThread02 = threading.Thread(target=sub)subThread01.start()subThread02.start()subThread01.join()subThread02.join()print("num result : %s" % num)# 结果三次采集
# num result : 0
# num result : 0
# num result : 0
with语句

由于threading.RLock()对象中实现了enter__()与__exit()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import threadingnum = 0def add():with lock:# 自动加锁global numfor i in range(10_000_000):num += 1# 自动解锁def sub():with lock:# 自动加锁global numfor i in range(10_000_000):num -= 1# 自动解锁if __name__ == "__main__":lock = threading.RLock()subThread01 = threading.Thread(target=add)subThread02 = threading.Thread(target=sub)subThread01.start()subThread02.start()subThread01.join()subThread02.join()print("num result : %s" % num)# 结果三次采集
# num result : 0
# num result : 0
# num result : 0

3、Condition() 条件锁

基本介绍

条件锁是在递归锁的基础上增加了能够暂停线程运行的功能。

并且我们可以使用wait()与notify()来控制线程执行的个数。

注意：条件锁可以自由设定一次放行几个线程。

下面是threading模块与条件锁提供的相关方法：

使用方式

下面这个案例会启动10个子线程，并且会立即将10个子线程设置为等待状态。

然后我们可以发送一个或者多个通知，来恢复被等待的子线程继续运行：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import threadingcurrentRunThreadNumber = 0
maxSubThreadNumber = 10def task():global currentRunThreadNumberthName = threading.currentThread().namecondLock.acquire()  # 上锁print("start and wait run thread : %s" % thName)condLock.wait()  # 暂停线程运行、等待唤醒currentRunThreadNumber += 1print("carry on run thread : %s" % thName)condLock.release()  # 解锁if __name__ == "__main__":condLock = threading.Condition()for i in range(maxSubThreadNumber):subThreadIns = threading.Thread(target=task)subThreadIns.start()while currentRunThreadNumber < maxSubThreadNumber:notifyNumber = int(input("Please enter the number of threads that need to be notified to run："))condLock.acquire()condLock.notify(notifyNumber)  # 放行condLock.release()print("main thread run end")# 先启动10个子线程，然后这些子线程会全部变为等待状态
# start and wait run thread : Thread-1
# start and wait run thread : Thread-2
# start and wait run thread : Thread-3
# start and wait run thread : Thread-4
# start and wait run thread : Thread-5
# start and wait run thread : Thread-6
# start and wait run thread : Thread-7
# start and wait run thread : Thread-8
# start and wait run thread : Thread-9
# start and wait run thread : Thread-10# 批量发送通知，放行特定数量的子线程继续运行
# Please enter the number of threads that need to be notified to run：5  # 放行5个
# carry on run thread : Thread-4
# carry on run thread : Thread-3
# carry on run thread : Thread-1
# carry on run thread : Thread-2
# carry on run thread : Thread-5# Please enter the number of threads that need to be notified to run：5  # 放行5个
# carry on run thread : Thread-8
# carry on run thread : Thread-10
# carry on run thread : Thread-6
# carry on run thread : Thread-9
# carry on run thread : Thread-7# Please enter the number of threads that need to be notified to run：1
# main thread run end
with语句

由于threading.Condition()对象中实现了enter__()与__exit()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

import threadingcurrentRunThreadNumber = 0
maxSubThreadNumber = 10def task():global currentRunThreadNumberthName = threading.currentThread().namewith condLock:print("start and wait run thread : %s" % thName)condLock.wait()  # 暂停线程运行、等待唤醒currentRunThreadNumber += 1print("carry on run thread : %s" % thName)if __name__ == "__main__":condLock = threading.Condition()for i in range(maxSubThreadNumber):subThreadIns = threading.Thread(target=task)subThreadIns.start()while currentRunThreadNumber < maxSubThreadNumber:notifyNumber = int(input("Please enter the number of threads that need to be notified to run："))with condLock:condLock.notify(notifyNumber)  # 放行print("main thread run end")

4、Event() 事件锁

基本介绍

事件锁是基于条件锁来做的，它与条件锁的区别在于一次只能放行全部，不能放行任意个数量的子线程继续运行。

我们可以将事件锁看为红绿灯，当红灯时所有子线程都暂停运行，并进入“等待”状态，当绿灯时所有子线程都恢复“运行”。

下面是threading模块与事件锁提供的相关方法：

使用方式

事件锁不能利用with语句来进行使用，只能按照常规方式。

如下所示，我们来模拟线程和红绿灯的操作，红灯停，绿灯行：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
# 生成一个事件锁对象
eve = threading.Event()# 将事件锁设置为红灯状态
eve.clear()# 判断事件锁的状态
eve.is_set()# 将当前线程设置’等待‘状态
eve.wait()# 将事件锁设置为绿灯状态
eve.set()import time
import threadingdef light(eve):print(f'当前时间:{time.ctime()}, 红灯还有 5s 结束!')time.sleep(5)print(f'当前时间:{time.ctime()}, 绿灯亮!')eve.set()   # 设置事件锁标志为 Truedef car(eve, name):print(f'当前时间:{time.ctime()}, 车 {name} 正在等红灯')eve.wait()    # 将当前线程设置为等待状态，等待事件锁标志为 True 再执行print(f'当前时间:{time.ctime()}, 车 {name} 开始通行')if __name__ == '__main__':eve = threading.Event()   # 事件锁默认标志为 Falset1 = threading.Thread(target=light, args=(eve,))t1.start()for each in 'ABCDE':t2 = threading.Thread(target=car, args=(eve, each))t2.start()# 执行看一下打印结果
当前时间:Fri Jul 29 11:32:58 2022, 红灯还有 5s 结束!
当前时间:Fri Jul 29 11:32:58 2022, 车 A 正在等红灯
当前时间:Fri Jul 29 11:32:58 2022, 车 B 正在等红灯
当前时间:Fri Jul 29 11:32:58 2022, 车 C 正在等红灯
当前时间:Fri Jul 29 11:32:58 2022, 车 D 正在等红灯
当前时间:Fri Jul 29 11:32:58 2022, 车 E 正在等红灯
当前时间:Fri Jul 29 11:33:03 2022, 绿灯亮!
当前时间:Fri Jul 29 11:33:03 2022, 车 C 开始通行
当前时间:Fri Jul 29 11:33:03 2022, 车 B 开始通行
当前时间:Fri Jul 29 11:33:03 2022, 车 E 开始通行
当前时间:Fri Jul 29 11:33:03 2022, 车 A 开始通行
当前时间:Fri Jul 29 11:33:03 2022, 车 D 开始通行

5、Semaphore() 信号量锁

基本介绍

信号量锁也是根据条件锁来做的，它与条件锁和事件锁的区别如下：

  • 条件锁：一次可以放行任意个处于“等待”状态的线程

  • 事件锁：一次可以放行全部的处于“等待”状态的线程

  • 信号量锁：通过规定，成批的放行特定个处于“上锁”状态的线程

下面是threading模块与信号量锁提供的相关方法：

使用方式

以下是使用示例，你可以将它当做一段限宽的路段，每次只能放行相同数量的线程：

import threading
import timemaxSubThreadNumber = 6def task():thName = threading.currentThread().namesemaLock.acquire()print("run sub thread %s" % thName)time.sleep(3)semaLock.release()if __name__ == "__main__":# 每次只能放行2个semaLock = threading.Semaphore(2)for i in range(maxSubThreadNumber):subThreadIns = threading.Thread(target=task)subThreadIns.start()# run sub thread Thread-1
# run sub thread Thread-2# run sub thread Thread-3
# run sub thread Thread-4# run sub thread Thread-6
# run sub thread Thread-5
with语句

由于threading.Semaphore()对象中实现了enter__()与__exit()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：926207505
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import threading
import timemaxSubThreadNumber = 6def task():thName = threading.currentThread().namewith semaLock:print("run sub thread %s" % thName)time.sleep(3)if __name__ == "__main__":semaLock = threading.Semaphore(2)for i in range(maxSubThreadNumber):subThreadIns = threading.Thread(target=task)subThreadIns.start()

锁关系浅析

上面5种锁可以说都是基于同步锁来做的，这些你都可以从源码中找到答案。

首先来看RLock递归锁，递归锁的实现非常简单，它的内部会维护着一个计数器，当计数器不为0的时候该线程不能被I/O操作和时间轮询机制切换。

但是当计数器为0的时候便不会如此了：

def __init__(self):self._block = _allocate_lock()self._owner = Noneself._count = 0  # 计数器

而Condition条件锁的内部其实是有两把锁的，一把底层锁（同步锁）一把高级锁(递归锁)。

低层锁的解锁方式有两种，使用wait()方法会暂时解开底层锁同时加上一把高级锁，只有当接收到别的线程里的notfiy()后才会解开高级锁和重新上锁低层锁，也就是说条件锁底层是根据同步锁和递归锁的不断切换来进行实现的：

def __init__(self, lock=None):    if lock is None:        lock = RLock()  # 可以看到条件锁的内部是基于递归锁，而递归锁又是基于同步锁来做的    self._lock = lock    self.acquire = lock.acquire    self.release = lock.release    try:        self._release_save = lock._release_save    except AttributeError:        pass    try:       self._acquire_restore = lock._acquire_restore    except AttributeError:        pass    try:        self._is_owned = lock._is_owned    except AttributeError:        pass    self._waiters = _deque()

基本练习题

1. 条件锁的应用

需求：一个空列表，两个线程轮番往里面加值（一个加偶数，一个加奇数），最终让该列表中的值为 1 - 100 ，且是有序排列的。

import threadinglst = []def even():"""加偶数"""with condLock:for i in range(2, 101, 2):# 判断当前列表的长度处于2是否能处尽# 如果能处尽则代表需要添加奇数# 否则就添加偶数if len(lst) % 2 != 0:# 添偶数lst.append(i)      # 先添加值condLock.notify()  # 告诉另一个线程，你可以加奇数了，但是这里不会立即交出执行权condLock.wait()    # 交出执行权，并等待另一个线程通知加偶数else:# 添奇数condLock.wait()  # 交出执行权，等待另一个线程通知加偶数lst.append(i)condLock.notify()condLock.notify()def odd():"""加奇数"""with condLock:for i in range(1, 101, 2):if len(lst) % 2 == 0:lst.append(i)condLock.notify()condLock.wait()condLock.notify()if __name__ == "__main__":condLock = threading.Condition()addEvenTask = threading.Thread(target=even)addOddTask = threading.Thread(target=odd)addEvenTask.start()addOddTask.start()addEvenTask.join()addOddTask.join()print(lst)

2. 事件锁的应用

有2个任务线程来扮演李白和杜甫，如何让他们一人一句进行对答？文本如下：

杜甫：老李啊，来喝酒！

李白：老杜啊，不喝了我喝不下了！

杜甫：老李啊，再来一壶？

杜甫：…老李？

李白：呼呼呼…睡着了…

代码如下：

import threadingdef libai():event.wait()  print("李白：老杜啊，不喝了我喝不下了！")event.set()event.clear()event.wait()print("李白：呼呼呼...睡着了..")def dufu():print("杜甫：老李啊，来喝酒！")event.set()  event.clear()event.wait()print("杜甫：老李啊，再来一壶？")print("杜甫：...老李？")event.set()if __name__ == '__main__':event = threading.Event()t1 = threading.Thread(target=libai)t2 = threading.Thread(target=dufu)t1.start()t2.start()t1.join()t2.join()

尾语

最后感谢你观看我的文章呐~本次航班到这里就结束啦 🛬

希望本篇文章有对你带来帮助 🎉，有学习到一点知识~

躲起来的星星🍥也在努力发光，你也要努力加油（让我们一起努力叭）。

最后，宣传一下呀~👇👇👇更多源码、资料、素材、解答、交流皆点击下方名片获取呀👇👇

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/417410.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

spingboot 集成identityserver4身份验证

spingboot 集成identityserver4身份验证

一、新建项目&#xff1a;com.saas.swaggerdemo 详情见&#xff1a;spring-boot2.7.8添加swagger-CSDN博客 在之前项目基础上添加如下依赖 <dependency><groupId>com.nimbusds</groupId><artifactId>nimbus-jose-jwt</artifactId><version&…
阅读更多...
如何用“CentOS7 安装Mysql”？

如何用“CentOS7 安装Mysql”？

1、 yum安装更方便 yum install wget 2、 新建文件夹 [rootlocalhost bin]# cd /usr/local/ [rootlocalhost local]# mkdir mysql [rootlocalhost local]# cd mysql [rootlocalhost mysql]# 3、 下载并安装MySQL官方的 Yum Repository wget http://dev.mysql.com/get/mys…
阅读更多...
Docker-安装实践(mysql,redis集群,tomcat)

Docker-安装实践(mysql,redis集群,tomcat)

docker实践(提供几个安装案例&#xff09; 安装Tomcat # 拉取镜像,可以指定标签不指定默认为最新 docker pull tomcat docker run -itd -p 8080:8080 --name tomcat tomcat:latest #这样内部默认80端口&#xff0c;主机的映射端口会随机分配一个 docker run -itd -P tomcat…
阅读更多...
【HarmonyOS】掌握布局组件，提升应用体验

【HarmonyOS】掌握布局组件，提升应用体验

从今天开始&#xff0c;博主将开设一门新的专栏用来讲解市面上比较热门的技术 “鸿蒙开发”&#xff0c;对于刚接触这项技术的小伙伴在学习鸿蒙开发之前&#xff0c;有必要先了解一下鸿蒙&#xff0c;从你的角度来讲&#xff0c;你认为什么是鸿蒙呢&#xff1f;它出现的意义又是…
阅读更多...
【每日一题】—— A. Chemistry（900分思维）

【每日一题】—— A. Chemistry（900分思维）

&#x1f30f;博客主页&#xff1a;PH_modest的博客主页 &#x1f6a9;当前专栏&#xff1a;每日一题 &#x1f48c;其他专栏&#xff1a; &#x1f534; 每日反刍 &#x1f7e1; C跬步积累 &#x1f7e2; C语言跬步积累 &#x1f308;座右铭&#xff1a;广积粮&#xff0c;缓称…
阅读更多...
Linux 查看时区及修改时区的方法

Linux 查看时区及修改时区的方法

查看时区 ll /etc/localtime可以看到这里显示的是纽约的时区 修改时区 timedatectl set-timezone Asia/Shanghai如图所示&#xff0c;表示修改成功为上海时区
阅读更多...
每日一题——LeetCode1287.有序数组中出现次数超过25%的元素

每日一题——LeetCode1287.有序数组中出现次数超过25%的元素

方法一 一次循环统计 题目给出的数据相同的元素都是相邻的&#xff0c;那么直接从头开始遍历&#xff0c;统计每种元素出现次数&#xff0c;当有元素次数超过arr.length/4即为要求的元素 var findSpecialInteger function(arr) {let countMath.floor(arr.length/4),num1conso…
阅读更多...
【涨薪技术】掌握加密签名接口测试实战！

【涨薪技术】掌握加密签名接口测试实战！

接口加密是指在网络传输过程中&#xff0c;将数据进行加密&#xff0c;以保护数据的安全性。接口加密可以采用多种加密算法&#xff0c;如AES、DES、RSA等。测试接口加密的目的是验证接口加密算法的正确性和安全性。 1加密与加密算法 加密&#xff08;Encrypt&#xff09;是将…
阅读更多...
Linux问题 apt-get install时 无法解析域名“cn.archive.ubuntu.com”

Linux问题 apt-get install时 无法解析域名“cn.archive.ubuntu.com”

问题描述: 在安装程序时会出现无法解析域名的错误 解决办法: 1、编辑文件 sudo vim /etc/resolv.conf 2、在最后加上(按键 i 进入编辑模式) nameserver 8.8.8.8 3、保存退出(:wq)
阅读更多...
使用 FFmpeg 轻松调整视频的大小/缩放/更改分辨率

使用 FFmpeg 轻松调整视频的大小/缩放/更改分辨率

在此 FFmpeg 教程中&#xff0c;我们学习使用 FFmpeg 的命令行工具更改视频的分辨率&#xff08;或调整视频的大小/缩放&#xff09;。 更改视频的分辨率&#xff08;也称为调整大小或缩放&#xff09;是视频编辑、处理和压缩中非常常见的操作。对于 ABR 视频流尤其如此&#…
阅读更多...
深入解析JavaScript中的var、let和const

深入解析JavaScript中的var、let和const

&#x1f9d1;‍&#x1f393; 个人主页&#xff1a;《爱蹦跶的大A阿》 &#x1f525;当前正在更新专栏&#xff1a;《VUE》 、《JavaScript保姆级教程》、《krpano》、《krpano中文文档》 ​ ​ ✨ 前言 变量的声明是编程中非常基础和关键的概念。在ES6之前,JavaScript只有…
阅读更多...
力扣：474. 一和零（动态规划）（01背包）

力扣：474. 一和零（动态规划）（01背包）

题目&#xff1a; 给你一个二进制字符串数组 strs 和两个整数 m 和 n 。 请你找出并返回 strs 的最大子集的长度&#xff0c;该子集中 最多 有 m 个 0 和 n 个 1 。 如果 x 的所有元素也是 y 的元素&#xff0c;集合 x 是集合 y 的 子集 。 示例 1&#xff1a; 输入&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023