线程和并发编程剩余小知识点

线程和并发编程剩余小知识点

一、多线程实现TCP服务端并发

'''服务端'''
import socket
from multiprocessing import Process


def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    return server


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


if __name__ == '__main__':
    server = get_server()
    while True:
        sock, addr = server.accept()
        # 开设多进程聊天吧
        p = Process(target=get_talk, args=(sock,))
        p.start()      
        
'''客户端'''
import socket
client = socket.socket()
client.connect(('127.0.0.1',8080))

while True:
    client.send(b'hello baby')
    data = client.recv(1024)
    print(data)

二、互斥锁代码实操

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


def search(name):
    with open(r'data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    print('%s查看票 目前剩余:%s' % (name, data.get('ticket_num')))


def buy(name):
    # 先查询票数
    with open(r'data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    # 模拟网络延迟
    time.sleep(random.randint(1, 3))
    # 买票
    if data.get('ticket_num') > 0:
        with open(r'data.json', '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()
        
# 锁：建议只加在操作数据的部分，否则整个程序的效率会极低
# 锁的种类很多(行锁，表锁)，但是作用都一样 
# 强调：互斥锁只应该出现在多个程序操作数据的地方，其他位置尽量不要加。以后自己处理锁的情况少，只需要知道锁的功能即可。

from multiprocessing import Process,Lock # 导入锁模块
mutex = Lock()    # 上锁
mutex.acquire()   # 抢锁
mutex.release()   # 释放锁

三、线程

1.线程理论

在传统的操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程
多线程的概念是在一个进程中存在多个线程，多个线程共享仅存的地址空间，相当于车间内有多条流水线，都共有一个车间的资源

2.线程和进程的区别

进程：其实是资源单位，表示一块内存空间
线程：其实是执行单位，表示真正的代码指令
'''我们可以将进程比喻是车间，线程是车间里面的流水线'''
一个进程内部至少含义一个线程
1.一个进程内可以开设多个线程
2.同一个进程下的多个线程数据是共享的
3.创建进程的消耗要远远大于线程

3.创建线程的两种方法

# 第一种
from threading import Thread
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()
    t_list = []
    for i in range(100):
        t = Thread(target=task,args=('用户%s'%i,))
        t.start()
        t_list.append(t)
    for i in t_list:
        t.join()
    print(time.time() - start_time)
t = Thread(target=task,args=('jason',))
t.start()
print('zhu')
# 创建线程无需考虑反复执行的问题

# 第二种
from threading import Thread
import time

class MyThread(Thread):
    def run(self):
        print('run is running')
        time.sleep(1)
        print('run is over')
obj = MyThread()
obj.start()
print('zhu')

四、线程的诸多特性

1.多线程实现TCP服务端开发

# 多线程比多进程更加简单方便，消耗的资源更少
# 服务端
import socket
from threading import Thread

server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)

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

while True:
    sock, addr = server.accept()
    # 开设进程去完成数据交互
    p = Thread(target=talk, args=(sock,))
    p.start()
    
# 客户端
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'hello big baby')
    data = client.recv(1024)
    print(data.decode('utf8'))

2.join方法

# 主线程等到子线程运行结束之后再运行
from threading import Thread
import time

def task():
    print('正在执行')
    time.sleep(3)
    print('运行结束')

t = Thread(target=task)
t.start()
t.join()
print('主线程')

3.同一个进程下线程间数据共享

from threading import Thread

money = 1000

def func():
    global money
    money = 666

t = Thread(target=func)
t.start()
t.join()  # 确保线程运行完毕 再查找money 结果更具有说服性
print(money)

4.线程对象相关方法

1.进程号
同一个进程下开设的多个线程拥有相同的进程号
2.线程名
from threading import Thread, current_thread
current_thread().name
主线程：MainThread   子线程：Thread-N(N表示进程数)
3.进程下的线程数
active_count()  正在运行的线程数量

补充：
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行线程启动后、结束前，不包括启动前和终止后的线程。
threading.active_count: 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。# 注意主线程也算!!!
threading.current_thread().name:获取当前线程的名字。
    
# 代码展示
from threading import Thread, current_thread, active_count
import time
import os

def task():
    print('子线程运行task函数')
    time.sleep(3)
    print('子线程运行task结束')
    print('子线程', os.getpid())
    print('子线程名', current_thread().name)

if __name__ == '__main__':
    print('主线程', os.getpid())
    for i in range(4):
        t = Thread(target=task, )
        t.start()
    print('当前进程下存活的线程数>>>:', active_count())

5.守护线程

# 主线程结束了子线程也会结束的
# 正常情况
from threading import Thread
import time

def task():
    print('子线程运行task函数')
    time.sleep(3)
    print('子线程运行task结束')

t = Thread(target=task)
t.start()
print('主线程')

# 子线程运行task函数
# 主线程
# 子线程运行task结束


# 守护
from threading import Thread
import time

def task():
    print('子线程运行task函数')
    time.sleep(3)
    print('子线程运行task结束')

t = Thread(target=task)
t.daemon = True
t.start()
# t.daemon = True  # 只能放在start前，否则会报错
print('主线程')
# 子线程运行task函数
# 主线程

五、GIL全局解释器锁

储备知识：
Python解释器也是由编程语言写出来的：
Cpython            用c编写
Jpython            用java编写
Pypython           用python编写
# 最常用的是Cpython 

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 JPython PyPython (常用的是CPython解释器)
2.GIL本质也是一把互斥锁，用来阻止同一个进程内多个线程同时执行
3.GIL存在使得同一个进程下的多个线程无法同时执行(单线程下的多线程无法利用多核优势，效   率低)
4.GIL的存在是因为CPython解释器中内存管理不是线程安全的(垃圾回收机制)

六、验证GIL的存在

from threading import Thread

num = 100
def task():
    global num
    num -= 1
# 存储每个线程
t_list = []
for i in range(100):
    # 创建线程对象
    t = Thread(target=task)
    t.start()
    t_list.append(t)   # [线程1,线程2,线程3...线程100]
for t in t_list:
    # 主线程等到子线程结束
    t.join()
print(num)

七、GIL与普通互斥锁

GIL只能确保同进程内多线程数据不会被垃圾回收机制弄乱，并不能确保程序里的数据是否安全，想要保证得自己加锁。

from threading import Thread,Lock
import time

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
1.1IO密集型
多进程：申请额外的空间，消耗更多的资源
多线程：消耗资源相对较少，通过多道技术
PS：多线程有优势
1.2计算密集型
多进程：申请额外的空间，消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
多线程：消耗资源相对较少，通过多道技术(总耗时+切换)
PS：多线程有优势
2.多个CPU
2.1IO密集型
多进程：总耗时(单个进程的好事+IO+申请空间+拷贝代码)
多线程：总耗时(单个进程的好事+IO)
PS：多线程有优势
2.1计算密集型
多进程：总耗时(单个进程耗时)
多线程：总耗时(多个进程的总和)
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
"""

from threading import Thread
from multiprocessing import Process
import os
import time
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()

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