进程: 应用程序的实例,有独立的内存空间和系统资源
进程的特点:独立(内存独立,CPU使用独立)启动进程开销大(效率低),进程之间很难共享数据,和数据通信,数据安全高
线程: CPU调度和分派的基本单位,进程中的每个子任务不能独立存在,CPU执行的最小单位,可完成一个独立的顺序控制流程.
线程的特点: 依赖进程(内存共享,CPU使用独立)启动开销小, 线程之间共享数据容易,方便通信,线程不安全*进程,线程的目的: 都是想同时完成任务.
多线程: 1.如果在一个进程中同时运行多个线程,用来完成不同的工作,则称之为”多线程”
2.多个线程交替占用CPU资源,而非真正的并执行.
多线程好处:1.充分利用CPU的资源 2.简化编程模型 3.带来良好的用户体验
Python中对线程的处理提供了threading模块 ,还包含其他方法
1.threading.currentThread(): 返回当前的线程变量。
2.threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
3.threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
4.getName(): 返回线程名。
5.setName(): 设置线程名。
import threading,time
print([x for x in range(9)])
thread=threading.current_thread()# 返回当前的线程变量
thread.setName('主线程')
print('threa name:',thread.getName())
new_th=threading.enumerate()
print('正在运行的线程:',new_th)#返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
print('正在运行线程的个数:',len(threading.enumerate()))执行命令得
[0, 1, 2, 3, 4, 5, 6, 7, 8]
threa name: 主线程
正在运行的线程: [<_MainThread(主线程, started 4548)>]
正在运行线程的个数: 1
除了使用方法外，线程模块同样提供了Thread类来处理线程
1.继承threading.Thread
2.写构造方法，且必须调用父类的构造方法
3.重写父类的 run 方法,会在 start 之后自动调用
4.实现开始方法，如果重写了 start() 方法，一定要调用父类的 start() 需要调用start()方法才可以执行
Thread类提供了以下方法:
1.run(): 用以执行线程活动的方法。
2.start():启动线程活动使线程达到一个就绪状态
加 注 : 线程的状态
3.join([time]):强制调用某个线程进入执行状态,本线程礼让CPU资源，进入阻塞，休眠状态，直至某个线程退出/抛异常/超时 本线程才进入就绪状态 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
4.isAlive(): 返回线程是否活动的。
import threading,time #导入threading模块 time模块
class Mythread(threading.Thread): #写类方法 继承threading.Thread
def __init__(self): #写构造方法
super().__init__();
print('Mythread __init__()')
time.sleep(0.1)#休眠01.s
def run(self): #重写父类run方法
for i in range(10):
print(self.getName(),i)
time.sleep(0.1)
#创建俩个线程,并让他们去同时启动
t1=Mythread()
t2=Mythread()
t1.start()
t2.start()
#测试 join( ) 方法 括号里面添加时间,单位为秒
for i in range(10):
print(threading.current_thread().getName(),i) #当前线程的名字
time.sleep(0.1)
if i==5: #随哪个线程调用,哪个线程就停止
t1.join()
new_th=threading.enumerate()
print('正在运行的线程:',new_th)执行命令得
Mythread __init__()
Mythread __init__()
Thread-1 0
Thread-2 0
MainThread 0
Thread-2 1
MainThread 1
Thread-1 1
MainThread 2
Thread-2 2
Thread-1 2
Thread-2 3
Thread-1 3
MainThread 3
Thread-2 4
Thread-1 4
MainThread 4
MainThread 5
Thread-1 5
Thread-2 5
Thread-1 6
Thread-2 6
Thread-1 7
Thread-2 7
Thread-2 8
Thread-1 8
Thread-1 9
Thread-2 9
MainThread 6
MainThread 7
MainThread 8
MainThread 9
正在运行的线程: [<_MainThread(MainThread, started 5572)>]使用函数方法:
函数实现方式：线程必须依赖函数实现，不能单独运行。当函数结束，线程结束。所以如果想让线程一直运行，就要想办法让程序不结束，比如在程序最后加一个input(),或死循环。
#首先导入包
import threading,time
#
# #以函数方法去实现可以达到资源共享
def something(x):
for i in range(x):
print(i)
time.sleep(2)
threading._start_new_thread(something,(6,)) #括号里面的必须是个元组
input() #这个很重要
'''''
输出为: 0 1 2 3 4 5
一个抢票的例子:
import threading,time
nums=50
count=0
lock=threading.Lock#创建一把锁
Cond=threading.Condition()#管理锁
class qiangpiao(threading.Thread):
def __init__(self,name):
threading.Thread.__init__(self)
self.setName(name)
def run(self):
global nums,count
while True:
Cond.acquire()#当哪个线程获得了资源 就就加上锁
if nums==0:
return
nums-=1
count+=1
print('{0}抢到了{1} 剩余{2}'.format(self.getName(),count,nums))
time.sleep(0.2)
Cond.release()#当哪个线程
if __name__=='__main__':
huangniu=qiangpiao('黄牛')
lvtu=qiangpiao('旅途')
xiecheng=qiangpiao('携程')
huangniu.start()
lvtu.start()
xiecheng.start()
# 多线程共享执行得
黄牛抢到了1 剩余49
黄牛抢到了2 剩余48
黄牛抢到了3 剩余47
黄牛抢到了4 剩余46
携程抢到了5 剩余45
携程抢到了6 剩余44
携程抢到了7 剩余43
旅途抢到了8 剩余42
旅途抢到了9 剩余41
携程抢到了10 剩余40
携程抢到了11 剩余39
携程抢到了12 剩余38
携程抢到了13 剩余37
携程抢到了14 剩余36
携程抢到了15 剩余35
携程抢到了16 剩余34
携程抢到了17 剩余33
携程抢到了18 剩余32
携程抢到了19 剩余31
旅途抢到了20 剩余30
黄牛抢到了21 剩余29
黄牛抢到了22 剩余28
黄牛抢到了23 剩余27
黄牛抢到了24 剩余26
黄牛抢到了25 剩余25
黄牛抢到了26 剩余24
旅途抢到了27 剩余23
旅途抢到了28 剩余22
旅途抢到了29 剩余21
携程抢到了30 剩余20
携程抢到了31 剩余19
携程抢到了32 剩余18
携程抢到了33 剩余17
携程抢到了34 剩余16
黄牛抢到了35 剩余15
黄牛抢到了36 剩余14
携程抢到了37 剩余13
旅途抢到了38 剩余12
旅途抢到了39 剩余11
旅途抢到了40 剩余10
黄牛抢到了41 剩余9
黄牛抢到了42 剩余8
黄牛抢到了43 剩余7
携程抢到了44 剩余6
携程抢到了45 剩余5
黄牛抢到了46 剩余4
旅途抢到了47 剩余3
旅途抢到了48 剩余2
旅途抢到了49 剩余1
旅途抢到了50 剩余0