线程理论
1、什么是线程？
线程指的是一条流水线的工作过程
进程不是执行单位，是资源单位
一个进程内自带一个线程，线程是执行单位
2、进程VS线程
1、同一个进程内的线程们共享该进程内的资源，不同进程内的线程资源肯定是隔离的。
2、创建线程的开销比创建进程要小的多
4、线程中没有父子关系。相较于子线程，主线程的特殊之处在于其改变了主进程的生命周期。
主进程等待子进程结束然后结束，是为子进程回收资源。
主线程等待子线程结束然后结束，是等待这个进程的代码(其他非守护线程)执行完毕。
线程对象其他相关属性或方法
主进程等子进程是因为主进程要给子进程收尸
进程必须等待其内部所有线程都运行完毕才结束
from threading import Thread
import time
def task(name):
print('%s is running' %name)
time.sleep(3)
print('%s is done' %name)
if __name__ == '__main__':
t=Thread(target=task,args=('子线程',))
t.start()
print('主')
#
from threading import Thread,current_thread,active_count,enumerate#active_count查看活跃的进程数量
import time
def task():
print('%s is running' % current_thread().name) # current_thread 在当前线程内拿到自己的线程对象
time.sleep(3)
print('%s is done' % current_thread().name)
if __name__ == '__main__':
t = Thread(target=task,name='xxx')
t.start()
# t.join()
# print(t.is_alive())
# print(t.getName())
# print(t.name)
# print('主',active_count())
# print(enumerate()) #返回当前活跃的所有线程对象
# t.join()
current_thread().setName('主线程')
print('主',current_thread().name)
主进程:执行完代码就结束。
主线程:所以子线程结束才结束。
进程在运行本质是线程在运行
===================================================================
描述进程的运行:申请内存空间，但凡产生的数据都往里面丢
描述线程的运行:代码从上到下执行(前提是空间已经开辟好了)
一个程序的运行过程涉及到资源开辟，代码运行过程从上到下执行
CPU上运行的单位是线程
开启线程的两种方式
from threading import Thread
import time
#方式一
def task(name):
print('%s is running' %name)
time.sleep(3)
print('%s is done' %name)
if __name__ == '__main__':
t=Thread(target=task,args=('子线程',))
t.start()
print('主')
#方式二
class Mythread(Thread):
def run(self):
print('%s is running' %self.name)
time.sleep(3)
print('%s is done' %self.name)
if __name__ == '__main__':
t=Mythread()
t.start()
print('主')
线程VS进程
1、线程的开启速度快
from threading import Thread
from multiprocessing import Process
import time
def task(name):
print('%s is running' %name)
time.sleep(3)
print('%s is done' %name)
if __name__ == '__main__':
t=Thread(target=task,args=('子线程',))
# t=Process(target=task,args=('子进程',))
t.start()
print('主')
2、同一进程下的多个线程共享该进程内的数据
from threading import Thread
import time
x=100
def task():
global x
x=0
if __name__ == '__main__':
t=Thread(target=task,)
t.start()
# time.sleep(3)
t.join()
print('主',x)
# 查看pid
from threading import Thread
import time,os
def task():
print(os.getpid())
if __name__ == '__main__':
t=Thread(target=task,)
t.start()
print('主',os.getpid())
守护线程
守护线程会会在本进程内所有非守护的线程都死掉了才跟着死
from threading import Thread,current_thread
import time
def task():
print('%s is running' % current_thread().name)
time.sleep(3)
print('%s is done' % current_thread().name)
if __name__ == '__main__':
t = Thread(target=task,name='守护线程')
t.daemon=True
t.start()
print('主')
from threading import Thread
import time
def foo():
print(123)
time.sleep(3)
print("end123")
def bar():
print(456)
time.sleep(1)
print("end456")
t1=Thread(target=foo)
t2=Thread(target=bar)
t1.daemon=True
t1.start()
t2.start()
print("main-------")
'''
123
456
main-------
end456
'''
互斥锁 (目前不理解)
from threading import Thread,Lock
import time
mutex=Lock()
x=100
def task():
global x
# mutex.acquire()
temp=x
time.sleep(0.1) #x-=1
x=temp-1
# mutex.release()
if __name__ == '__main__':
t_l=[]
start=time.time()
for i in range(100):#起了100个线程
t=Thread(target=task)
t_l.append(t)#t线程加到列表里
t.start()
for t in t_l:
t.join()#让其串行就可以了
stop=time.time()
print(x,stop-start)
死锁现象与递归现象(待定)
pass
信号量(待定)
pass