今日内容详细

互斥锁代码实操

锁：建议只加载操作数据的部分 否则整个程序的效率会很低
def search(name):
    with open(r'joyce.txt', 'r', encoding='utf8') as f:
        data = json.load(f)
    print('%s查看票 目前剩余:%s' % (name, data.get('ticket_num')))


def buy(name):
    with open(r'joyce.txt', 'r', encoding='utf8') as f:
        data = json.load(f)
    # 模拟网络延迟 随机秒数
    time.sleep(random.randint(1, 3))
    # 买票
    if data.get('ticket_num') > 0:
        with open(r'joyce.txt', 'w', encoding='utf8') as f:
            data['ticket_num'] -= 1
            json.dump(data, f)
        print('%s买票成功' % name)
    else:
        print('%s 买票失败 '% name)

def run(name,mutex):
    search(name)
    mutex.acquire()
    buy(name)
    mutex.release()

if __name__ == '__main__':
    mutex = Lock() #产生一把锁
    for i in range(10):
        p=Process(target=run,args=('用户%s' % i,mutex))
        p.start()

在买票时 用户首先查看剩余票 可以有很多用户同时查看 票只有一张的情况下 就只能有一个人买 这时就需要互斥锁 谁抢到锁了 谁就有资格去买票

锁有很多种 但是作用都是一样的

线程理论

进程

​ 进程其实就是资源单位 便是一块内存空间

线程

​ 线程才是执行单位 表示真正的代码指令

我们可以将进程比喻成是车间 线程是车间里面的流水线

一个进程内部至少含有一个线程

1.一个线程内可以开设多个线程

2.同一个进程下的多个线程数据是共享的

3.创建进程与线程的区别

​ 创建进程的消耗要远远大于线程

创建线程的两种方式


方式1：
from threading import Thread
from  multiprocessing import Process
import time


def task(name):
    print(f'{name} is running')
    time.sleep(0.1)
    print(f'{name}is over')

if __name__ == '__main__':
    start_time = time.time()
    p_list = []
    for i in range(10):
        p = Process(target=task,args=('用户%s'% i,))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print(time.time()-start_time)
    t_list = []
    for i in range(10):
        t = Thread(target=task,args=('用户%s'%i,))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print(time.time()-start_time)

t = Thread(target=task,args=('jason',))
t.start()
print('主进程')
'''
创建线程无需考虑反复执行的问题
'''
方式2：
class MyThread(Thread):
    def run(self):
        print('run is running')
        time.sleep(1)
        print('run is over')

obj = MyThread()
obj.start()
print('主线程')

线程的诸多特性

1.join方法

2.同进程内多个线程数据共享

3.current_thread()

4.active_count()

GIL全局解释器锁

# 官方文档对GIL的解释
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.

1.在Cpython解释器中存在全局解释锁 简称GIL

​ python解释器有很多种类型 常用：Cpython Jpthon PYpython

2.GIL本质也是一把互斥锁 用来阻止同一个进程内多个线程同时执行（重要）

3.GIL的存在是因为Cpython解释器中内存管理不是线程安全的（垃圾回收机制）

​ 垃圾回收机制（引用计数、标记清楚、分代回收）

验证GIL的存在

from threading import Thread
num = 100
def task():
    global num
    num -=1

t_list = []
for i in range(10):
    t= Thread(target=task)
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(num)

GIL与普通互斥锁

既然Cpython解释器中有GIL 那么我们以后写代码是不是就不需要操作锁了？

”’

GIL只能够去日报同进程内多线程数据不会被垃圾回收机制弄乱 并不能确保程序里面的数据是否安全

”’

import time
from threading import Thread,Lock
num = 100

def task(mutex):
    global num
    mutex.acquire()
    count = num
    time.sleep(0.1)
    num = count-1
    mutex.release()

mutex = Lock()
t_list = []
for i in range(100):
    t = Thread(target=task,args=(mutex,))
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(num)

python多线程是否有用

需要分情况

​ 情况1

​ 单个CPU

​ 多个CPU

​ 情况2

​ IO密集型（代码有IO操作）

​ 计算密集型（代码没有IO操作）

1.单个CPU

​ IO密集型

​ 多进程

​ 申请额外的空间 消耗更多的资源

​ 多线程

​ 消耗资源相对较少 通过多道技术

​ ps：多线程有优势！

​ 计算密集型

​ 多进程

​ 申请额外的空间 消耗更多的资源（总耗时+申请空间+拷贝代码+切换）

​ 多线程

​ 消耗资源相对较少 通过多道技术（总耗时+切换）

​ ps：多线程有优势

2.多个CPU

​ IO密集型

​ 多进程

​ 总耗时（单个进程的好事+IO+申请空间+拷贝代码）

​ 多线程

​ 总耗时（单个进程的耗时+IO）

​ ps：多线程有优势！

​ 计算密集型

​ 多进程

​ 总耗时（单个进程的耗时）

​ 多线程

​ 总耗时（多个进程的综合）

​ ps：多进程完胜

from threading import Thread
from multiprocessing import Process
import os
import time


def work():
    # 计算密集型
    res = 1
    for i in range(1, 100000):
        res *= i


if __name__ == '__main__':
    # print(os.cpu_count())  # 12  查看当前计算机CPU个数
    start_time = time.time()
    # p_list = []
    # for i in range(12):  # 一次性创建12个进程
    #     p = Process(target=work)
    #     p.start()
    #     p_list.append(p)
    # for p in p_list:  # 确保所有的进程全部运行完毕
    #     p.join()
    t_list = []
    for i in range(12):
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))  # 获取总的耗时

"""
计算密集型
    多进程:5.665567398071289
    多线程:30.233906745910645
"""

def work():
    time.sleep(2)   # 模拟纯IO操作


if __name__ == '__main__':
    start_time = time.time()
    # t_list = []
    # for i in range(100):
    #     t = Thread(target=work)
    #     t.start()
    # for t in t_list:
    #     t.join()
    p_list = []
    for i in range(100):
        p = Process(target=work)
        p.start()
    for p in p_list:
        p.join()
    print('总耗时:%s' % (time.time() - start_time))

"""
IO密集型
    多线程:0.0149583816528320
    多进程:0.6402878761291504
"""

死锁现象

acquire()
release()

from threading import Thread,Lock
import time

mutexA = Lock()  # 产生一把锁
mutexB = Lock()  # 产生一把锁


class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')

    def func2(self):
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        time.sleep(1)
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')

for i in range(10):
    obj = MyThread()
    obj.start()

信号量

在python并发编程中信号量相当于多把互斥锁(公共厕所)
	
from threading import Thread, Lock, Semaphore
import time
import random


sp = Semaphore(5)  # 一次性产生五把锁


class MyThread(Thread):
    def run(self):
        sp.acquire()
        print(self.name)
        time.sleep(random.randint(1, 3))
        sp.release()


for i in range(20):
    t = MyThread()
    t.start()

event事件

from threading import Thread, Event
import time

event = Event()  # 类似于造了一个红绿灯


def light():
    print('红灯亮着的 所有人都不能动')
    time.sleep(3)
    print('绿灯亮了 油门踩到底 给我冲!!!')
    event.set()


def car(name):
    print('%s正在等红灯' % name)
    event.wait()
    print('%s加油门 飙车了' % name)


t = Thread(target=light)
t.start()
for i in range(20):
    t = Thread(target=car, args=('熊猫PRO%s' % i,))
    t.start()

进程池与线程池

进程和线程能否无限制的创建 >>>不可以

因为硬件的发展赶不上软件 有物理极限 如果我们在编写代码的过程中无限制的创建进程或者线程可能会导致计算机崩溃

池

​ 降低程序的执行效率 但是保证了计算机硬件的安全

进程池

​ 提前创建好固定数量的进程供后续程序的调用 超出则等待

线程池

​ 提前创建好固定数量的线程供后续程序的调用 超出则等待

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import os
import time
import random
from threading import current_thread

# 1.产生含有固定数量线程的线程池
# pool = ThreadPoolExecutor(10)
pool = ProcessPoolExecutor(5)


def task(n):
    print('task is running')
    # time.sleep(random.randint(1, 3))
    # print('task is over', n, current_thread().name)
    # print('task is over', os.getpid())
    return '我是task函数的返回值'


def func(*args, **kwargs):
    print('from func')

if __name__ == '__main__':
    # 2.将任务提交给线程池即可
    for i in range(20):
        # res = pool.submit(task, 123)  # 朝线程池提交任务
        # print(res.result())  # 不能直接获取
        # pool.submit(task, 123).add_done_callback(func)

协程

进程：资源单位

线程：执行单位

协程：单线程下实现并发（效率极高）

​ 在代码层面欺骗cpu 让cpu觉得我们代码里面没有IO 操作

​ 实际上IO操作被我们自己写的代码检测 一旦有 立刻让代码执行别的

​ （该技术完全是程序员自己弄出来的 名字也是程序员自己起的 ）

​ 核心：自己写代码完成切换+把偶你状态

import time
from gevent import monkey;

monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn


def func1():
    print('func1 running')
    time.sleep(3)
    print('func1 over')


def func2():
    print('func2 running')
    time.sleep(5)
    print('func2 over')


if __name__ == '__main__':
    start_time = time.time()
    # func1()
    # func2()
    s1 = spawn(func1)  # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
    s2 = spawn(func2)
    s1.join()
    s2.join()
    print(time.time() - start_time)  # 8.01237154006958   协程 5.015487432479858

携程实现并发

import socket
from gevent import monkey;monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn


def communication(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())


def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    while True:
        sock, addr = server.accept()  # IO操作
        spawn(communication, sock)

s1 = spawn(get_server)
s1.join()

如何不断的提升程序的运行效率
	多进程下开多线程 多线程下开协程

原文地址：http://www.cnblogs.com/lzy199911/p/16912998.html

1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！ 2. 分享目的仅供大家学习和交流，请务用于商业用途! 3. 如果你也有好源码或者教程，可以到用户中心发布，分享有积分奖励和额外收入！ 4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！ 5. 如有链接无法下载、失效或广告，请联系管理员处理！ 6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！ 7. 如遇到加密压缩包，默认解压密码为"gltf",如遇到无法解压的请联系管理员！ 8. 因为资源和程序源码均为可复制品，所以不支持任何理由的退款兑现，请斟酌后支付下载 声明：如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性