1     TCP服务端实现并发
 2         1.将不同的功能尽量拆分成不同的函数
 3             拆分出来的功能可以被多个地方使用
 4
 5         1.将连接循环和通信循环拆分成不同的函数
 6         2.将通信循环做成多线程
 7
 8
 9     GIL(全局解释器锁)
10     在CPython解释器才有GIL的概念，不是python的特点
11     GIL也是一把互斥锁
12         将并发变成串行 牺牲了效率但是提高了数据的安全
13         ps:
14             1.针对不同的数据 应该使用不同的锁去处理
15             2.自己不要轻易的处理锁的问题 哪怕你知道acquire和release
16             当业务逻辑稍微复杂的一点情况下 极容易造成死锁
17     CPython中的GIL的存在是因为python的内存管理不是线程安全的
18
19     内存管理
20         引用计数:值与变量的绑定关系的个数
21         标记清除:当内存快要满的时候 会自动停止程序的运行 检测所有的变量与值的绑定关系
22                 给没有绑定关系的值打上标记，最后一次性清除
23         分代回收:(垃圾回收机制也是需要消耗资源的，而正常一个程序的运行内部会使用到很多变量与值
24         并且有一部分类似于常量，减少垃圾回收消耗的时间，应该对变量与值的绑定关系做一个分类
25         )        新生代(5S)》》》青春代(10s)》》》老年代(20s)
26                 垃圾回收机制扫描一定次数发现关系还在，会将该对关系移至下一代
27                 随着代数的递增 扫描频率是降低的
28
29
30     同一个进程下的多个线程能否同时运行
31     GIL类似于是加在解释器上面的一把锁

 1 from multiprocessing import Process
 2 from threading import Thread
 3 import os,time
 4 def work():
 5     res=0
 6     for i in range(100000000):
 7         res*=i
 8
 9
10 if __name__ == '__main__':
11     l=[]
12     print(os.cpu_count())  # 本机为6核
13     start=time.time()
14     for i in range(6):
15         # p=Process(target=work) #耗时  4.732933044433594
16         p=Thread(target=work) #耗时 22.83087730407715
17         l.append(p)
18         p.start()
19     for p in l:
20         p.join()
21     stop=time.time()
22     print('run time is %s' %(stop-start))

 1 from multiprocessing import Process
 2
 3 import os,time
 4 def work():
 5     time.sleep(2)
 6
 7 if __name__ == '__main__':
 8     l=[]
 9     print(os.cpu_count()) #本机为6核
10     start=time.time()
11     for i in range(4000):
12         p=Process(target=work) #耗时9.001083612442017s多,大部分时间耗费在创建进程上
13         # p=Thread(target=work) #耗时2.051966667175293s多
14         l.append(p)
15         p.start()
16     for p in l:
17         p.join()
18     stop=time.time()
19     print('run time is %s' %(stop-start))

 1 from threading import Thread
 2 import time
 3
 4 n = 100
 5
 6
 7 def task():
 8     global n
 9     tmp = n
10     time.sleep(1)
11     n = tmp -1
12
13 t_list = []
14 for i in range(100):
15     t = Thread(target=task)
16     t.start()
17     t_list.append(t)
18
19 for t in t_list:
20     t.join()
21
22 print(n)

 1 from threading import Thread,Lock,current_thread,RLock
 2 import time
 3 """
 4 Rlock可以被第一个抢到锁的人连续的acquire和release
 5 每acquire一次锁身上的计数加1
 6 每release一次锁身上的计数减1
 7 只要锁的计数不为0 其他人都不能抢
 8
 9 """
10 # mutexA = Lock()
11 # mutexB = Lock()
12 mutexA = mutexB = RLock()  # A B现在是同一把锁
13
14
15 class MyThread(Thread):
16     def run(self):  # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
17         self.func1()
18         self.func2()
19
20     def func1(self):
21         mutexA.acquire()
22         print('%s抢到了A锁'%self.name)  # self.name等价于current_thread().name
23         mutexB.acquire()
24         print('%s抢到了B锁'%self.name)
25         mutexB.release()
26         print('%s释放了B锁'%self.name)
27         mutexA.release()
28         print('%s释放了A锁'%self.name)
29
30     def func2(self):
31         mutexB.acquire()
32         print('%s抢到了B锁'%self.name)
33         time.sleep(1)
34         mutexA.acquire()
35         print('%s抢到了A锁' % self.name)
36         mutexA.release()
37         print('%s释放了A锁' % self.name)
38         mutexB.release()
39         print('%s释放了B锁' % self.name)
40
41 for i in range(10):
42     t = MyThread()
43     t.start()

 1 from threading import Semaphore,Thread
 2 import time
 3 import random
 4
 5 sm = Semaphore(5)  # 造了一个含有五个的坑位的公共厕所
 6
 7 def task(name):
 8     sm.acquire()
 9     print('%s占了一个坑位'%name)
10     time.sleep(random.randint(1,3))
11     sm.release()
12
13 for i in range(40):
14     t = Thread(target=task,args=(i,))
15     t.start()

 1 from threading import Event,Thread
 2 import time
 3
 4 # 先生成一个event对象
 5 e = Event()
 6
 7
 8 def light():
 9     print('红灯正亮着')
10     time.sleep(3)
11     e.set()  # 发信号
12     print('绿灯亮了')
13
14 def car(name):
15     print('%s正在等红灯'%name)
16     e.wait()  # 等待信号
17     print('%s加油门飙车了'%name)
18
19 t = Thread(target=light)
20 t.start()
21
22 for i in range(10):
23     t = Thread(target=car,args=('伞兵%s'%i,))
24     t.start()

 1 import socket
 2 from threading import Thread
 3
 4 """
 5 服务端
 6     1.要有固定的IP和PORT
 7     2.24小时不间断提供服务
 8     3.能够支持并发
 9 """
10
11 server = socket.socket()
12 server.bind(('127.0.0.1',8080))
13 server.listen(5)
14
15
16 def talk(conn):
17     while True:
18         try:
19             data = conn.recv(1024)
20             if len(data) == 0:break
21             print(data.decode('utf-8'))
22             conn.send(data.upper())
23         except ConnectionResetError as e:
24             print(e)
25             break
26     conn.close()
27
28 while True:
29     conn, addr = server.accept()  # 监听 等待客户端的连接  阻塞态
30     print(addr)
31     t = Thread(target=talk,args=(conn,))
32     t.start()

 1 import socket
 2
 3
 4 client = socket.socket()
 5 client.connect(('127.0.0.1',8080))
 6
 7 while True:
 8     client.send(b'hello')
 9     data = client.recv(1024)
10     print(data.decode('utf-8'))