线程

今日内容概要

• 线程相关知识点
• 开启线程的两种方式
• TCP服务端实现并发的效果
• 线程对象的join方法
• 线程间数据共享
• 数据对象属性及其他方法
• 守护线程
• 线程互斥锁
• GIL全局解释器锁
• 多进程与多线程的实际应用场景

今日内容详细

线程相关知识点

#   什么是线程
'''
进程：资源单位
线程：执行单位

将操作系统比喻成一个大的工厂
那么进程就相当于工厂里面的车间
而线程就是车间里面的流水线

每一个进程肯定自带一个线程

总结：
	进程：资源单位(起一个进程仅仅只是在内存空间中开辟一块独立的空间)
	线程：执行单位(真正被cpu执行的其实是进程里面的线程，线程指的就是代码的执行过程
	，执行代码中所需要使用到的资源都找所在的进程索要)

进程和线程都是虚拟单位，只是为了我们更加方便的描述问题
'''

# 为何要有线程
'''
开设进程
	1.申请内存空间  耗资源
	2.'拷贝代码'    耗资源

开线程
	一个进程内可以开设多个线程，在用一个进程内开设多个线程无需再次申请内存空间及拷贝代码的操作
	
总结：开设线程的开销要远远的小于进程的开销
	 同一个进程下的多个线程数据是共享的
'''
我们要开发一款文本编辑器
	获取用户输入的功能
    实时展示到屏幕的功能
    自动保存到硬盘的功能
针对上面这三个功能，开设进程还是线程合适？
	开三个线程处理上面的三个功能更加的合理
    

# 如何使用：开线程的两种方式
from multiprocessing import Process
from threading import Thread
import time

# 第一种方式
# def task(name):
#     print('%s is running'%name)
#     time.sleep(3)
#     print('%s is over'%name)
#
#
# # 开启线程不需要在main下面执行代码 直接书写就可以
# # 但是我们还是习惯性的将启动命令写在main下面
# t = Thread(target=task,args=('egon',))
# t.start()
# print('主')
# '''
# 线程运行结果：
# egon is running
# 主
# egon is over
# '''
#
#
# # if __name__ == '__main__':
# #     p = Process(target=task, args=('jason',))
# #     p.start()
# #     print('主')
# '''
# 进程运行结果：
# 主
# jason is running
# jason is over
# '''
#
# # 运行结果顺序不一样是因为，进程需要先去创建内存空间



# 第二种方式
class MyThread(Thread):
    def __init__(self,name):
        # 读法：双下init
        # 重写了别人的方法 又不知道别人的方法里有啥 你就调用父类的方法
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running'%self.name)
        time.sleep(2)
        print('egon DSB')


if __name__ == '__main__':
    t = MyThread('egon')
    t.start()
    print('主')

• TCP服务端实现并发的效果

  # TCP服务端并发
  import socket
  from threading import Thread
  from multiprocessing import Process
  
  '''
  服务端
      1.要有固定的IP和PORT
      2.24小时不间断提供服务
      3.能够支持并发
  '''
  
  server = socket.socket()  # 默认tcp协议
  server.bind(('127.0.0.1',8888))
  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()
      # 叫其他人来服务客户
      # t = Thread(target=talk,args=(conn,))
      t = Process(target=talk,args=(conn,))
      t.start()
      
      
  
  
      
  # 客户端
  import socket
  
  
  client = socket.socket()
  client.connect(('127.0.0.1',8888))
  
  while True:
      client.send(b'hello world')
      data = client.recv(1024)
      print(data.decode('utf-8'))
  

• 线程对象的join方法

  from threading import Thread
  import time
  
  
  def task(name):
      print('%s is running'%name)
      time.sleep(3)
      print('%s is over'%name)
  
  if __name__ == '__main__':
      t = Thread(target=task,args=('egon',))
      t.start()
      t.join()  # 主线程等待子线程运行结束再执行
      print('主')
  

• 同一个进程下的多个线程间数据是共享的

  from threading import Thread
  import time
  
  money = 100
  
  def task():
      global money
      money = 666
      print(money)
  
  
  if __name__ == '__main__':
      t = Thread(target=task)
      t.start()
      t.join()
      print(money)
  

• 数据对象属性及其他方法

  from threading import Thread,active_count,current_thread
  import time,os
  
  
  def task(n):
      # print('hello world',os.getpid())
      print('hello world',current_thread().name)  # 获取当前线程的名字
      # hello world Thread-1
      time.sleep(n)
  
  
  
  if __name__ == '__main__':
      t = Thread(target=task,args=(1,))
      t1 = Thread(target=task,args=(2,))
      t.start()
      t1.start()
      # t.join()  # 打开这个，线程数为2
      # t1.join()  # 打开这个，线程数为1
  
      print('主',active_count())  # 统计当前正在活跃的线程数
      # print('主',os.getpid())
      # print('主',current_thread().name)
      # 主 MainThread
  

• 守护线程

  # from threading import Thread
  # import time
  #
  # def task(name):
  #     print('%s is running'%name)
  #     time.sleep(1)
  #     print('%s is over'%name)
  #
  #
  # if __name__ == '__main__':
  #     t = Thread(target=task,args=('jason',))
  #     t.daemon = True
  #     t.start()
  #     print('主')
  '''
  主线程运行结束之后不会立刻结束，会等其他非守护线程结束之后才会结束
      因为主线程的结束意味着所在进程的结束
  '''
  
  
  # 稍有迷惑的案例
  from threading import Thread
  import time
  
  
  def foo():
      print(123)
      time.sleep(1)
      print('end123')
  
  def bar():
      print(456)
      time.sleep(3)
      print('end456')
  
  
  if __name__ == '__main__':
      t1 = Thread(target=foo)
      t2 = Thread(target=bar)
      t1.daemon = True
      t1.start()
      t2.start()
      print('主')
  

• 线程互斥锁

  from threading import Thread,Lock
  import time
  
  money = 100
  mutex = Lock()
  
  
  def task():
      global money
      mutex.acquire()
      tmp = money
      time.sleep(0.1)
      money = tmp - 1
      mutex.release()
  
  
  if __name__ == '__main__':
      lis = []
      for i in range(100):
          t = Thread(target=task)
          t.start()
          lis.append(t)
  
      for t in lis:
          t.join()
      print(money)
  

• 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.)
  '''
  '''
  python解释器其实有多个版本
      Cpython
      Jpython
      Pypypython
  但是普遍使用的都是CPython解释器
  
  在CPython解释器中GIL是一把互斥锁，用来阻止同一个进程下的多个线程的同时执行
  	同一个进程下的多个线程无法利用多核优势
  	疑问：python的多线程是不是一点用都没有？无法利用多核优势
  
  因为cpython中的内存管理不是线程安全的
  内存管理(垃圾回收机制)
  	1、引用计数
  	2、标记清除
  	3、分代回收
  '''
  
  '''
  重点：
  	1、GIL不是python的特点而是CPython解释器的特点
  	2、GIL是保证解释器级别的数据的安全
  	3、GIL会导致同一个进程下的多个线程无法同时执行即无法利用多核优势(******)
  	4、针对不同的数据还是需要加不同的锁处理
  	5、解释型语言的通病：同一个进程下多个线程无法利用多核优势
  '''
  

• GIL与普通互斥锁的区别

  from threading import Thread,Lockimport timemoney = 100mutex = Lock()def task():    global money    # with mutex:  # 等价于mutex.acquire()   mutex.release()    #     mutex.acquire()    #     tmp = money    #     time.sleep(0.1)    mutex.acquire()    tmp = money    time.sleep(0.1)  # 只要你进入了IO，GIL会自动释放    money = tmp - 1    mutex.release()if __name__ == '__main__':    lis = []    for i in range(100):        t = Thread(target=task)        t.start()        lis.append(t)    for t in lis:        t.join()    print(money)'''100个线程起来之后 要先去抢GIL我进入io GIL自动释放 但是我手上还有一个自己的互斥锁其他线程虽然抢到了GIL，但是没有抢到互斥锁最终GIL还是回到你的手上 你去操作数据'''
  

• 同一个进程下的多线程无法利用多核优势，是不是就没有用了

  '''多线程是否有用要看具体情况单核：四个任务(IO密集型\计算密集型)多核：四个任务(IO密集型\计算密集型)'''# 计算密集型  每个任务都需要10秒单核：(不用考虑)    多进程：额外的消耗资源    多线程：介绍开销多核：	多进程：总耗时 10+    多线程：总耗时 40+# IO密集型  每个任务都需要10秒多核：	多进程：相对浪费资源    多线程：更加节省资源
  

• 验证多进程与多线程的实际应用场景

  # # 计算密集型# import os# import time# from threading import Thread# from multiprocessing import Process### def work():#     res = 0#     for i in range(10000000):#         res *= i### if __name__ == '__main__':#     l = []#     print(os.cpu_count())  # 获取当前计算机的cpu个数#     start_time = time.time()#     for i in range(16):#         # p = Process(target=work)  # 0.7446901798248291#         # p.start()#         # l.append(p)#         t = Thread(target=work)  # 4.7670910358428955#         t.start()#         l.append(t)#     for p in l:#         p.join()#     print(time.time() - start_time)# IO密集型import osimport timefrom threading import Threadfrom multiprocessing import Processdef work():    time.sleep(2)if __name__ == '__main__':    l = []    print(os.cpu_count())  # 获取当前计算机的cpu个数    start_time = time.time()    for i in range(4000):        p = Process(target=work)  # 51.89486360549927        p.start()        l.append(p)        # t = Thread(target=work)  # 2.4728267192840576        # t.start()        # l.append(t)    for p in l:        p.join()    print(time.time() - start_time)    
  

  总结

  '''多进程和多线程都有各自的优势并且后面在写项目的时候通常可以	多进程下面再开设多线程这样的话既可以利用多核也可以节省资源消耗'''