1.锁:Lock(一次放行一个)

  线程安全,多线程操作时,内部会让所有的线程排队处理。

  线程不安全:+人=>排队处理

  以后锁代码块

v=[]
lock=threading.Lock()#声明锁
def func(arg):
lock.acquire()#上锁
v.append(arg)
time.sleep(0.1)
m=v[-1]
print(arg,m)
lock.release()#解锁
for i in range(10):
t=threading.Thread(target=func,args=(i,))
t.start()
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9

2.锁:Rlock(一次放一个)

  支持递归锁,锁多次

v = []
lock = threading.RLock()
def func(arg):
lock.acquire()
# lock.acquire() v.append(arg)
time.sleep(0.01)
m = v[-1]
print(arg,m) lock.release()
# lock.release() for i in range(10):
t =threading.Thread(target=func,args=(i,))
t.start()
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9

3.一次放多个:BoundedSemaphore

  threading.BoundedSemaphore(指定一次放几个就放几个),信号量

import time
import threading
lock=threading.BoundedSemaphore(5)#指定几个就每次执行几个线程
def func(arg):
lock.acquire()
print(arg)
time.sleep(3)
lock.release()
for i in range(20):
t=threading.Thread(target=func,args=(i,))
t.start()

4.条件锁Condition(一次放指定个数,用户输入几个就放几个)******

方法一:
import time
import threading
lock=threading.Condition()#声明放的方式
def func(arg):
lock.acquire()
lock.wait()#上锁
print(arg)
time.sleep(2)
lock.release()
for i in range(20):
t=threading.Thread(target=func,args=(i,))
t.start()
while 1:
user=int(input(">>>"))
lock.acquire()
lock.notify(user)#重点操作
lock.release()
方法二:
def xxx():
input('>>>')
return True
def func(arg):
lock.wait_for(xxx)
print(arg)
time.sleep(1)
for i in range(10):
t=threading.Thread(target=func,args=(i,))
t.start()

5.Event(一次放所有)

import threading
import time
lock=threading.Event()声明一次放掉全部的线程
def func(arg):
lock.wait()加锁红灯
print(arg)
for i in range(10):
t=threading.Thread(target=func,args=(i,))
t.start()
input('>>>')
lock.set()解锁绿灯
lock.clear()再次红灯
for i in range(10):
t=threading.Thread(target=func,args=(i,))
t.start()
input('>>>')
lock.set()绿灯
 

总结:

  线程安全:列表和字典是线程安全的,队列。

  为什么要加锁?

  非线程安全的可以人为加锁,控制一段代码!

6.threading.local

作用:

  内部自动为每个线程维护一个空间(字典),用于当前存取属于自己的值,保证线程之间的数据隔离。

应用:
import threading
import time
v=threading.local()
def func(arg):
v.phone=arg
time.sleep(2)
print(v.phone,arg)
for i in range(10):
t=threading.Thread(target=func,args=(i,))
t.start()
原理:
import threading
import time
v=threading.local()
def func(arg):
v.phone=arg
time.sleep(2)
print(v.phone,arg)
for i in range(10):
t=threading.Thread(target=func,args=(i,))
t.start()

7.线程池:控制最多开指定的线程

import threading
from concurrent.futures import ThreadPoolExecutor
import time
def func(a1,a2):
time.sleep(2)
print(a1,a2)
pool = ThreadPoolExecutor(5)#创建线程池,最多5个线程
for i in range(20):
#去线程池中申请一个线程,让线程执行该函数
pool.submit(func,i,20)

8.生产者消费者模型

import threading
import queue
import time
q=queue.Queue()#线程安全
def func(id):
"""
生产者
:param id:
:return:
"""
while 1:
time.sleep(2)
q.put('包子')
print('厨子%s,做了一个包子' %id)
for i in range(1,5):
t=threading.Thread(target=func,args=(i,))
t.start()
def usera(id):
"""
消费者
:param id:
:return:
"""
while 1:
q.get()
print('第%s个顾客吃了一个包子' %id)
for i in range(1,8):
t=threading.Thread(target=usera,args=(i,))
t.start()

队列:先进先出

扩展:

  栈:后进先出

内容补充:

线程池在python2中是没有的,线程不能太多,会造成线程的上下切换,影响效率

进程和线程的区别?

1.进程是CPU资源分配的最小单元

线程是CPU计算的最小单元

2.一个进程中可以有多个线程,

3.对于python来说,进程线程和其他语言有差异,是由gill锁造成的,gill锁保证一个进程中,同一时刻只能有一个线程能被CPU调度

进程是进行数据隔离

线程是CPU工作的最小单元,共享进程中的所有资源,每个线程分担一些任务,最终执行

锁,threading local,以及生产者和消费者模型的更多相关文章

  1. 20181229(守护进程,互斥锁,IPC,生产者和消费者模型)

    一.守护进程 守护进程:一个进程B守护另一个进程A,当被守护的进程A结束,进程B也就结束了.(不一定同生,但会同死) 两个特点: ①守护进程会在主进程代码执行结束后就终止 ②守护进程内无法再开启子进程 ...

  2. 守护进程,互斥锁,IPC,生产者与消费者模型

    守护进程: b 进程守护 a进程,当a进程执行完毕时,b进程会跟着立马结束 守护进程用途: 如果父进程结束了,子进程无需运行了,就可以将子进程设置为父进程的守护进程 例如我们qq视频聊天时,当我们退出 ...

  3. 守护进程,互斥锁,IPC,队列,生产者与消费者模型

    小知识点:在子进程中不能使用input输入! 一.守护进程 守护进程表示一个进程b 守护另一个进程a 当被守护的进程结束后,那么守护进程b也跟着结束了 应用场景:之所以开子进程,是为了帮助主进程完成某 ...

  4. python并发编程之守护进程、互斥锁以及生产者和消费者模型

    一.守护进程 主进程创建守护进程 守护进程其实就是'子进程' 一.守护进程内无法在开启子进程,否则会报错二.进程之间代码是相互独立的,主进程代码运行完毕,守护进程也会随机结束 守护进程简单实例: fr ...

  5. python多线程+生产者和消费者模型+queue使用

    多线程简介 多线程:在一个进程内部,要同时干很多事情,就需要同时执行多个子任务,我们把进程内的这些子任务叫线程. 线程的内存空间是共享的,每个线程都共享同一个进程的资源 模块: 1._thread模块 ...

  6. Java线程(学习整理)--4---一个简单的生产者、消费者模型

     1.简单的小例子: 下面这个例子主要观察的是: 一个对象的wait()和notify()使用情况! 当一个对象调用了wait(),那么当前掌握该对象锁标记的线程,就会让出CPU的使用权,转而进入该对 ...

  7. Python之生产者&、消费者模型

    多线程中的生产者和消费者模型: 生产者和消费者可以用多线程实现,它们通过Queue队列进行通信. import time,random import Queue,threading q = Queue ...

  8. 【java线程系列】java线程系列之线程间的交互wait()/notify()/notifyAll()及生产者与消费者模型

    关于线程,博主写过java线程详解基本上把java线程的基础知识都讲解到位了,但是那还远远不够,多线程的存在就是为了让多个线程去协作来完成某一具体任务,比如生产者与消费者模型,因此了解线程间的协作是非 ...

  9. python queue和生产者和消费者模型

    queue队列 当必须安全地在多个线程之间交换信息时,队列在线程编程中特别有用. class queue.Queue(maxsize=0) #先入先出 class queue.LifoQueue(ma ...

  10. 人生苦短之我用Python篇(队列、生产者和消费者模型)

    队列: queue.Queue(maxsize=0) #先入先出 queue.LifoQueue(maxsize=0) #last in fisrt out  queue.PriorityQueue( ...

随机推荐

  1. JS单引号嵌套的问题,怎么改才能对呢!

    JS单引号嵌套的问题,怎么改才能对呢! https://zhidao.baidu.com/question/416584343.html document.getElementById(celbid) ...

  2. 中国MOOC_零基础学Java语言_第4周 循环控制_2念整数

    2 念整数(5分) 题目内容: 你的程序要读入一个整数,范围是[-100000,100000].然后,用汉语拼音将这个整数的每一位输出出来. 如输入1234,则输出: yi er san si 注意, ...

  3. ELK日志分析之安装

    ELK日志分析之安装 1.介绍: NRT elasticsearch是一个近似实时的搜索平台,从索引文档到可搜索有些延迟,通常为1秒. 集群 集群就是一个或多个节点存储数据,其中一个节点为主节点,这个 ...

  4. Intellij Idea使用教程汇总篇

    Java编程强大的工具IDEA使用教程及一些快捷键收藏如下: https://blog.csdn.net/fanrenxiang/article/details/80503490

  5. MySQL学习-基础练习题

    day1 学生表操作: 1. 查询出班级205有多少个男生 2. 查询出名字为4个字的所有学生信息(编号.姓名,年龄,班级) 3. 查询出所有姓王的学生信息(编号.姓名,年龄,班级) 4. 查询出班级 ...

  6. mybatis一级缓存和二级缓存的使用

    在mybatis中,有一级缓存和二级缓存的概念: 一级缓存:一级缓存 Mybatis的一级缓存是指SQLSession,一级缓存的作用域是SQLSession, Mabits默认开启一级缓存.在同一个 ...

  7. [19/06/07-星期五] CSS基础_布局&定位&背景样式

    一.固定布局(不适应设备的浏览器的变化) <!DOCTYPE html> <html> <head> <meta charset="UTF-8&qu ...

  8. JExcel - 学习总结(1)

    1.什么是JExcel JExcel是Java对Excel进行操作的包,可以实现创建一个Excel并写入或读取Excel的数据等操作: JExcel的主要类为: (1)Workbook:工作簿 (2) ...

  9. tensorflow学习笔记七----------卷积神经网络

    卷积神经网络比神经网络稍微复杂一些,因为其多了一个卷积层(convolutional layer)和池化层(pooling layer). 使用mnist数据集,n个数据,每个数据的像素为28*28* ...

  10. You-Get,多网站视频下载工具,非常方便

    You-Get是一个非常优秀的网站视频下载工具.使用You-Get可以很轻松的下载到网络上的视频.图片及音乐. 按Win+R键打开运行,输入cmd,再输入命令 pip install you-get, ...