标签：art   过程   target   传统   ade   focus   enc   uil   方案   

初识别线程

在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程,cpu真正的执行单位是线程.

在工厂中, 每个车间都有房子,而且每个车间默认就有一条流水线.

操作系统 ===> 工厂

进程 ===> 车间

线程 ===> 流水线

cpu ===> 电源

线程:cpu最小的执行单位

进程:资源集合/资源单位.

线程运行 = 运行代码

进程运行 = 各种资源 + 线程

右键运行:

申请内存空间,先把解释器丢进去并且把代码丢进去(进程做的),运行代码(线程).

进程和线程的区别:

过程描述的区别

线程==》单指代码的执行过程

进程==》资源的申请与销毁的过程

进程内存空间彼此隔离

同一个进程下的线程共享资源.

进程和线程的创建速度

进程需要申请资源开辟空间 慢

线程只是告诉操作系统一个执行方案 快

线程开启的两种方式

一、

 from threading improt Thread
 ?
 improt time
 def tesk():
   print(‘线程 start‘)
   time.sleep(2)
   print(‘线程  end‘)
 if __name__ == ‘__main__‘:
       t = Thread(tarfet = task)
       t.start()
       print(‘主线程‘)

二、

 from threading import Thread
 import time
 # 进程等待所有线程结束才会结束
 ?
 class Myt(Thread):
     def run(self):
         print(‘子线程 start‘)
         time.sleep(5)
         print(‘子线程 end‘)
 ?
 t = Myt()
 t.start()
 print(‘主线程‘)

子进程和子进程创建速度

 from threading import Thread
 from multiprocessing import Process
 import time
 ?
 def task(name):
     print(f‘{name} is running‘)
     time.sleep(2)
     print(f‘{name} is end‘)
 ?
 ?
 if __name__ == ‘__main__‘:
     t = Thread(target=task,args=(‘子线程‘,))
     p = Process(target=task,args=(‘子进程‘,))
     # t.start()
     p.start()
     print(‘主‘)
 启子线程的打印效果:
 ?
 子线程 is running
 主
 子线程 is end
 ?
 开启子进程打印效果:
 ?
 主
 子进程 is running
 子进程 is end
 ?
 ?
 进程和线程的创建速度
 开启子进程需要申请资源开辟空间 慢
 开启子线程只是告诉操作系统一个执行方案 快
 ?

子线程共享资源

 from threading  import Thread
 import time,os
 ?
 x = 100
 def task():
     global x
     x = 50
     print(os.getpid()) # 5204
 ?
 ?
 if __name__ == ‘__main__‘:
 ?
     t = Thread(target=task)
     t.start()
     time.sleep(2)
     print(x) # 50
     print(os.getpid()) # 5204
 ?

线程的join方法

 from threading import Thread
 import time
 def task(name,n):
     print(f‘{name} start‘)
     time.sleep(n)
     print(f‘{name} end‘)
 ?
 t1 = Thread(target=task,args=(‘线程1‘,1))
 t2 = Thread(target=task,args=(‘线程2‘,2))
 t3 = Thread(target=task,args=(‘线程3‘,3))
 start = time.time()
 t1.start()
 t2.start()
 t3.start()
 t1.join() # 111s
 t2.join() #
 t3.join()
 end = time.time() # 3.0039877891540527
 # 思考一下 在单核的情况下 多个线程是如何利用cpu的
 print(end-start)
 ?

线程的其他用法

 from threading import Thread,currentThread,enumerate,activeCount
 # import threading
 import time
 # threading.current_thread()
 # threading.current_thread()
 ?
 def task():
     print(‘子线程 start‘)
     time.sleep(2)
     print(‘子线程 end‘)
     print(enumerate())
     # print(currentThread(),‘子线程‘)
 if __name__ == ‘__main__‘:
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t1.start()
    t2.start()

守护线程

 # 守护线程 守护的是进程的运行周期
 from threading import Thread,enumerate,currentThread
 import time
 ?
 def task():
     print(‘守护线程开始‘)
     print(currentThread())
     time.sleep(20)
     # print(‘守护线程结束‘)
 ?
 def task2():
     print(‘子线程 start‘)
     time.sleep(5)
     print(enumerate())
     print(‘子线程 end‘)
 ?
 if __name__ == ‘__main__‘:
     t1 = Thread(target=task)
     t2 = Thread(target=task2)
     t1.daemon = True
     t2.start()
     t1.start()
     print(‘主‘)
 ?

线程相关

标签：art   过程   target   传统   ade   focus   enc   uil   方案   

原文地址：https://www.cnblogs.com/zfb123-/p/11537435.html