python成长之路11

一.线程： 创建线程有两种方式（本质是一样的，创建好线程之后，cpu调度创建好的线程时执行的其实是Thread的run()方法）： import threading

def f1(args):
print(args)
#方式一
t=threading.Thread(target=f1,args=(123,))
t.start()

#方式二
class MyThread(threading.Thread):
def __init__(self,func,args):
self.func=func
self.args=args
super(MyThread,self).__init__()
def run(self):
self.func(self.args)
t1=MyThread(f1,123)
t1.start() 123 123 队列： import queue

q=queue.Queue(2)
q.put(1)
q.put(2)
q.put(3,block=False) #设置不阻塞(block为False)，插不进去直接报错 Traceback (most recent call last): File "/Users/admin/Desktop/zy/test.py", line 10, in <module> q.put(3,block=False)   File "/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/queue.py", line 130, in put raise Full queue.Full import queue,threading,time

def f1(q):
q.put(123,timeout=3) #超时5s没有插进队列就会抛异常
q=queue.Queue(2)
q.put(1)
q.put(2)
t=threading.Thread(target=f1,args=(q,)) #子线程插入第三条数据
t.start() #创建好子线程啦,等待cpu调度
#情况一:
time.sleep(1) #主线程等待1s,子线程put超时3秒,先主线程get,后子线程put,put成功
#情况二:
time.sleep(5) #主线程等待5s,子线程put超时3秒,主线程没来得及get,子线程就put,会报错

q.get() import queue

q=queue.Queue()
q.put(1)
q.put(2)
print(q.get())
print(q.get())
print(q.get(block=False)) #设置不阻塞(block为False),队列里没有数据会报错 1 Traceback (most recent call last): 2 File "/Users/admin/Desktop/zy/test.py", line 12, in <module> print(q.get(block=False)) File "/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/queue.py", line 161, in get raise Empty queue.Empty import queue,threading,time

def f1(q):
print(q.get(timeout=3))
q=queue.Queue()
q.put(1)
q.put(2)
print(q.get())
print(q.get())
t=threading.Thread(target=f1,args=(q,))
t.start()
#情况一:
time.sleep(1) #主线程等待1s,子线程超时3s,主线程先put,子线程后get,不会报错
#情况二:
time.sleep(5) #主线程等待5s,子线程超时3s,子线程先get,主线程再put,子线程get不到数据,直接报错

q.put(3) #!/usr/bin/env python
# -*- coding:utf-8 -*-

import queue
#队列：先进先出
q=queue.Queue(10) #队列最大长度,默认是0 无限大
q.put(11,timeout=5) #放数据,默认阻塞True 阻塞时可以设置超时时间
q.put(22,block=False) #非阻塞，不等待
size=q.qsize() #队列长度
data=q.get(timeout=5) #取数据 默认阻塞True 阻塞时可以设置超时时间
data=q.get(block=False) #非阻塞，不等待
bool_num=q.empty() #队列为空返回True
bool_num=q.full() #队列满了返回True
q.join() #阻塞进程，当队列中任务执行完毕之后（q.task_done），不再阻塞
q.task_done() import queue
#队列：先进先出
q=queue.Queue(2) #队列最大长度,默认是0 无限大

q.put(11)
q.task_done()
q.put(22)

q.join() 阻塞进程 import queue
#队列：先进先出
q=queue.Queue(2) #队列最大长度,默认是0 无限大

q.put(11)
q.task_done()
q.put(22) #每执行完一步要执行下q.taskdone()
q.task_done()
q.join() 不阻塞 import queue
#队列：后进先出
q=queue.LifoQueue(5)
q.put(123) #优先级相同，先进先出
q.put(345)
q.put(456)

print(q.get())
print(q.get())
print(q.get()) 456 345 123 import queue
#队列：优先级
q=queue.PriorityQueue(5)

q.put((0,123)) #优先级相同，先进先出
q.put((1,345))
q.put((0,456))

print(q.get())
print(q.get())
print(q.get()) (0, 123) (0, 456) (1, 345) import queue
#队列：双向队列

q=queue.deque()
q.append(123)
q.append(456)
q.appendleft(789)
q.appendleft(890)
# 980 789 123 456
print(q.pop())
print(q.popleft()) 456 890 生产者消费者模型：功能：1.客户端不阻塞，不持续占用连接，解决瞬时高并发   2.程序解耦合（生产者改变不影响消费者那端） #!/usr/bin/env python
# -*- coding:utf-8 -*-

import threading,queue,time
q=queue.Queue(50)
def producter(user):
print("%s来买票啦" % user)
q.put("%s来买票啦" % user)
def consumer():
who=q.get()
time.sleep(5)
print(who + "--出票")

for i in range(4):
user="user" + str(i)
t=threading.Thread(target=producter,args=(user,))
t.start()
while True:
t1=threading.Thread(target=consumer)
t1.start() user0来买票啦 user1来买票啦 user2来买票啦 user3来买票啦 user1来买票啦--出票 user0来买票啦--出票 user2来买票啦--出票 user3来买票啦--出票 线程里锁的机制： 应用程序的最小单位是线程，他们共用这个应用程序里的资源，如果同时对某个数据进行修改的话，就会产生脏数据 解决：锁  #!/usr/bin/env python
# -*- coding:utf-8 -*-

import threading,queue,time
q=queue.Queue(5)
def producter(user):
print("%s来买票啦" % user)
q.put("%s来买票啦" % user)
num=12
def consumer(lock):
global num
lock.acquire() #上锁
who=q.get()
num-=1
time.sleep(2)
print(who + "--出票","剩余票数：%d" % num)
lock.release() #开锁
for i in range(4):
user="user" + str(i)
t=threading.Thread(target=producter,args=(user,))
t.start()
#lock=threading.Lock()
lock=threading.RLock() #构建锁对象 Lock只能加一重锁 RLock可以加多重锁
while True:
t1=threading.Thread(target=consumer,args=(lock,))
t1.start() user0来买票啦 user1来买票啦 user2来买票啦 user3来买票啦 user0来买票啦--出票 剩余票数：11 user1来买票啦--出票 剩余票数：10 user2来买票啦--出票 剩余票数：9 user3来买票啦--出票 剩余票数：8 #lock=threading.Lock()
#lock=threading.RLock() #构建锁对象 Lock只能加一重锁 RLock可以加多重锁
lock=threading.BoundedSemaphore(2) #上面两种锁都是每次放行1个线程，这个可放行多个 一次放行2个线程 #!/usr/bin/env python
# -*- coding:utf-8 -*-

import threading

def func(i,event):
print(i)
event.wait() #监测是什么灯，红灯停绿灯行
print(i+100)

event=threading.Event() #信号 收到信号就放行所有线程

for i in range(4):
t=threading.Thread(target=func,args=(i,event,))
t.start()

event.clear() #设置成红灯
inp=input(">>>:")
if inp == "1":
event.set() #设置成绿灯 0 1 2 3 >>>:1 100 101 102 103

---

线程池： #!/usr/bin/env python
# -*- coding:utf-8 -*-

import queue,threading,time
class ThreadPool:
def __init__(self,maxsize=5):
self.maxsize=maxsize
self._q=queue.Queue(maxsize)
for i in range(maxsize):
self._q.put(threading.Thread)
def get_thread(self):
return self._q.get()
def add_thread(self):
self._q.put(threading.Thread)

pool=ThreadPool(5)
def task(args,p):
print(args)
time.sleep(2)
p.add_thread()
for i in range(10):
t=pool.get_thread()
obj = t(target=task,args=(i,pool,))
obj.start() 3个缺点： 1.  进程： 共享空间： #!/usr/bin/env python
# -*- coding:utf-8 -*-

from multiprocessing import Process
from multiprocessing import queues
import multiprocessing
from multiprocessing import Manager

def foo(i,args):
args[i]=i+100
print(args.values())
if __name__ == "__main__":
obj=Manager()
li=obj.dict()
for i in range(5):
p = Process(target=foo,args=(i,li,))
p.start()
import time
time.sleep(2) [101] [101, 102] [101, 102, 103] [100, 101, 102, 103] [100, 101, 102, 103, 104]

转载于:https://www.cnblogs.com/meitangyanyan/p/5697959.html

总结

以上是生活随笔为你收集整理的python成长之路11的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。