TCP服务端支持并发

解决方式：开多线程

服务端

基础版

import socket """ 服务端 1.要有固定的IP和PORT 2.24小时不间断提供服务 3.能够支持并发 """ server = socket.socket() server.bind(('127.0.0.1',8080)) server.listen(5) def talk(conn): while True: try: data = conn.recv(1024) if len(data) == 0:break print(data.decode('utf-8')) conn.send(data.upper()) except ConnectionResetError as e: print(e) break conn.close() while True: conn, addr = server.accept() # 监听 等待客户端的连接 阻塞态 print(addr)

进阶版：支持并发

import socket from threading import Thread # ①多导入了这个 """ 服务端 1.要有固定的IP和PORT 2.24小时不间断提供服务 3.能够支持并发 """ server = socket.socket() server.bind(('127.0.0.1',8080)) server.listen(5) def talk(conn): while True: try: data = conn.recv(1024) if len(data) == 0:break print(data.decode('utf-8')) conn.send(data.upper()) except ConnectionResetError as e: print(e) break conn.close() while True: conn, addr = server.accept() # 监听 等待客户端的连接 阻塞态 print(addr) t = Thread(target=talk,args=(conn,)) # ②加了这个 t.start() # ③加了这个

客户端

import socket # 客户端都是一样的 client = socket.socket() client.connect(('127.0.0.1',8080)) while True: client.send(b'hello') data = client.recv(1024) print(data.decode('utf-8'))

GIL全局解释器锁

---

ps:python解释器有很多种 最常见的就是CPython解释器，GIL也是在CPython中的。

GIL本质也是一把互斥锁:（是加在解释器上的）

GIL的存在是因为CPython解释器的内存管理不是线程安全的

GIL工作原理：将并发变成串行牺牲效率保证数据的安全 ，用来阻止同一个进程下的多个线程的同时执行

?上面第二行的内存管理（也就是垃圾回收机制） （需要自己查一查背一背以下三个的描述）

1.引用计数：值与变量的绑定关系的个数

2.标记清除 ：当内存快要满的时候，会自动停止程序的运行，检测所有的变量和值得绑定关系

给没有绑定关系的值打上标记，最后一次性清除

3.分代回收：（垃圾回收机制也是需要消耗资源的，而正常一个程序的运行，内部会使用到很多变量和值，并且有一部分类似于常量python中没有常量的概念，减少垃圾回收消耗的时间，应该对变量和值的绑定关系做一个分类）

新生代(5s) >>> 青春代(10s) >>> 老年代(20s)

垃圾回收机制扫描一定次数发现关系还在，会将该对关系移至下一代

随着代数的递增 扫描频率是降低的

GIL是python的特点吗？

答：不是，是CPython解释器的特点。

单进程下多个线程无法利用多核优势是所有解释型语言的通病

答：正确，没有很好的解决方法，当前阶段用GIL解决（并非最佳解决方案）

针对不同的设备应该加不同的锁进行处理

验证：有了GIL之后在同一个进程内开多个线程还需不需要再加锁

from threading import Thread import time n = 100 def task(): global n tmp = n time.sleep(1) # 这里睡一秒，是IO操作，会将锁自动释放 # 这里所有人都先拿到n等于100，然后都睡一觉，都把锁放了， #再转到下面的代码，都把自己的数据改成99 n = tmp -1 # 如果上面的把time.sleep(1)注释掉的话，线程1会拿到锁然后执行到最后一行， # 把100改成99，执行结束了，就把锁放了，然后让下一个线程来抢， # 因为之前已经把全局修改为99，线程2会接着执行到代码结束得到98然后放掉锁， # 以此类推，最后输出的结果是：0 t_list = [] for i in range(100): t = Thread(target=task) t.start() t_list.append(t) for t in t_list: t.join() print(n)

（同一个进程内多个线程无法实现并行但是可以实现并发）

思考： python的多线程没法利用多核优势 ，是不是就是没有用了?

研究python的多线程是否有用

需要分情况讨论

四个任务 计算密集型的 10s 单核情况下 开线程更省资源 多核情况下 开进程 10s (可以用到多核同时执行) 开线程 40s

计算密集型 from multiprocessing import Process from threading import Thread import os,time def work(): res=0 for i in range(100000000): res*=i if __name__ == '__main__': l=[] print(os.cpu_count()) # 本机为6核 start=time.time() for i in range(6): # p=Process(target=work) #开进程耗时 4.732933044433594 p=Thread(target=work) #开线程耗时 22.83087730407715 # 本来是6核能一起运行的时间，现在是只用一个核， # 所以 计算密集型里（用线程的时间）≈（用进程的时间*核心数） l.append(p) p.start() for p in l: p.join() stop=time.time() print('run time is %s' %(stop-start))

四个任务 IO密集型的 单核情况下 开线程更节省资源 多核情况下 开线程更节省资源

# IO密集型 from multiprocessing import Process from threading import Thread import threading import os,time def work(): time.sleep(2) if __name__ == '__main__': l=[] print(os.cpu_count()) #本机为6核 start=time.time() for i in range(400): p=Process(target=work) #耗时9.001083612442017s多,大部分时间耗费在创建进程上 # p=Thread(target=work) #耗时2.051966667175293s多 # IO密集型里明显能感觉到，开线程更合理 l.append(p) p.start() for p in l: p.join() stop=time.time() print('run time is %s' %(stop-start))

python的多线程到底有没有用

需要看情况而定 并且肯定是有用的

并不能说明多线程和多进程一定是哪种最好，还是要多进程+多线程配合使用

---

以下都是了解知识点，代码多为伪代码

死锁与递归锁

死锁就是下面Lock可能出现的

递归锁就是下面的RLock

递归锁可以被连续的acquire( 前提是只有第一个抢到的人才能连续acquire )

只有RLock的引用计数为0才能被抢

只有第一个抢到RLock的线程才能将引用计数release为0

from threading import Thread,Lock,current_thread,# ①这里导入 RLock 加上下面的操作是解决死锁的方法之一（递归锁） import time """ Rlock可以被第一个抢到锁的人连续的acquire和release 每acquire一次锁身上的计数加1 每release一次锁身上的计数减1 只要锁的计数不为0 其他人都不能抢 """ mutexA = Lock() mutexB = Lock() # 这里两把锁是不一样的 # mutexA = mutexB = RLock() # A B现在是同一把锁 ② 这里换成这一句，就能解决死锁 class MyThread(Thread): def run(self): # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发 self.func1() self.func2() def func1(self): mutexA.acquire() print('%s抢到了A锁'%self.name) # self.name等价于current_thread().name mutexB.acquire() print('%s抢到了B锁'%self.name) mutexB.release() print('%s释放了B锁'%self.name) mutexA.release() print('%s释放了A锁'%self.name) def func2(self): mutexB.acquire() print('%s抢到了B锁'%self.name) time.sleep(1) mutexA.acquire() print('%s抢到了A锁' % self.name) mutexA.release() print('%s释放了A锁' % self.name) mutexB.release() print('%s释放了B锁' % self.name) for i in range(10): t = MyThread() t.start()

上面的代码块大概第十行，两个锁不一样，这里是说明：

# class Demo(object): # # pass # # # # obj1 = Demo() # # obj2 = Demo() # # print(id(obj1),id(obj2)) # 这里id不同 """ 只要类加括号实例化对象 无论传入的参数是否一样生成的对象肯定不一样 单例模式除外（单例是人为限制住了） """

自己千万不要轻易处理锁的问题

信号量

信号量可能在不同的领域中 对应不同的知识点

互斥锁:单个卫生间(一个坑位)

信号量:多个卫生间(多个坑位)

from threading import Semaphore,Thread import time import random sm = Semaphore(5) # 造了一个含有五个的坑位的公共厕所 def task(name): sm.acquire() print('%s占了一个坑位'%name) time.sleep(random.randint(1,3)) sm.release() for i in range(40): t = Thread(target=task,args=(i,)) # 这里args=(i,)就是给name传值， # 这里给name传的值就是i t.start()

task里面的sleep 如果里面的值是“1” 那就是五个人先抢到坑位，然后五个人同时释放，再让接下来5个人抢

如果是上面的randint(1,3)就不是五个人同时出来了

event事件

之前学过的join()方法是主进程等待子进程结束

是否让一个子进程等待另一个子进程结束呢？

下面是一个线程等另一个线程的模型

from threading import Event,Thread import time # 先生成一个event对象 e = Event() def light(): # 红绿灯 print('红灯正亮着') time.sleep(3) e.set() # 发信号 print('绿灯亮了') def car(name): # 汽车 print('%s正在等红灯'%name) e.wait() # 等待信号 print('%s加油门飙车了'%name) t = Thread(target=light) t.start() for i in range(10): t = Thread(target=car,args=('伞兵%s'%i,)) t.start()

这里就是子线程car等待子线程light

线程q

import queue """ 同一个进程下的多个线程本来就是数据共享 为什么还要用队列? 因为队列是管道+锁 使用队列你就不需要自己手动操作锁的问题 因为锁操作的不好极容易产生死锁现象 """ q = queue.Queue() q.put('hahha') print(q.get()) # 结果：hahha (这就是普通的 Queue ) -------------------------------------------------- q = queue.LifoQueue() # last in first out (堆栈) q.put(1) q.put(2) q.put(3) print(q.get()) # 结果：3 (因为这是最后一个加的) -------------------------------------------------- q = queue.PriorityQueue() # 优先级 Queue (支持手动设计优先级) # 数字越小 优先级越高 q.put((10,'haha')) # 注意得传元组，元组里面两个值，第一个值是优先级，第二个是参数 q.put((100,'hehehe')) q.put((0,'xxxx')) q.put((-10,'yyyy')) print(q.get()) # 结果：yyyy (因为这个优先级最高)

转载于:https://www.cnblogs.com/PowerTips/p/11351314.html

相关资源：sendmail.8.14.2.tar.gz