python:线程

进程: 应用程序的实例,有独立的内存空间和系统资源

进程的特点:独立(内存独立,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
#这是一个线程
print([x for x in range(9)])
#返回当前的线程变量 currentThread()
thread = threading.currentThread()
print('当前线程变量: ',thread)
#输出为:  当前线程变量:  <_MainThread(MainThread, started 13164)>

#用setName设置名字             getName获取名字
thread.setName('主线程')
print('thread name: ',thread.getName())
#输出为:  thread name:  主线程

# threading.enumerate() 返回一个包含正在运行的线程的list
new_th = threading.enumerate()
print('正在运行的线程: ',new_th)
#输出为: 正在运行的线程:  [<_MainThread(主线程, started 1608)>]

#threading.activeCount(): 返回正在运行的线程数量，
# 与len(threading.enumerate())有相同的结果。
print('正在运行的线程个数: ',threading.activeCount())
print('正在运行的线程个数: ',len(threading.enumerate()))
#输出为: 正在运行的线程个数:  1
#        正在运行的线程个数:  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(): 返回线程是否活动的。

#首先导入模块 threading 模块   和   time 模块
import threading,time

#写类方法 继承threading.Thread
class MyThread(threading.Thread):
    def __init__(self):   #写构造方法
        threading.Thread.__init__(self)  #这里有两种格式:super(MyThread, self).__init__() 
        print('MyThread __init__')

    def run(self):   #重写父类run方法
        for i in range(10):
            print(self.getName(),i)
            time.sleep(2) # 这是调用time模块 意思是运行的时间再次休眠一秒
            #单位是秒

#创建俩个线程,并让他们去同时启动
t = MyThread()
ts = MyThread()
t.start()
ts.start()
#调用 isAlive() 方法 返回值是 True  False
print('线程是否是活动的: ',t.isAlive())
print('线程是否是活动的: ',ts.isAlive())

'''
输出为: 
MyThread __init__
MyThread __init__
Thread-1 0
Thread-2 0
线程是否是活动的:  True
线程是否是活动的:  True
Thread-1 1
Thread-2 1
Thread-1 2
Thread-2 2
Thread-1 3
Thread-2 3
Thread-1 4
Thread-2 4
Thread-1 5
Thread-2 5
Thread-1 6
Thread-2 6
Thread-1 7
Thread-2 7
Thread-1 8
Thread-2 8
Thread-1 9
Thread-2 9
'''
#测试 join( ) 方法   括号里面添加时间,单位为秒
for i in range(5):

    #当前线程的名字
    print(threading.current_thread().getName(),i)
    time.sleep(2)
    if i == 2:
        #随哪个线程调用,哪个线程就停止
        #括号里面的额数字(10) 是等待时长, 然后就开始执行
        t.join(10)
new_th = threading.enumerate()
print('正在运行的线程: ',new_th)

'''
全部程序输出为:
MyThread __init__
MyThread __init__
Thread-1 0
Thread-2 0
MainThread 0
MainThread 1
Thread-1 1
Thread-2 1
Thread-1 2
MainThread 2
Thread-2 2
Thread-1 3
Thread-2 3
Thread-1 4
Thread-2 4
Thread-1 5
Thread-2 5
Thread-1 6
Thread-2 6
Thread-1 7
Thread-2 7
MainThread 3
Thread-1 8
Thread-2 8
MainThread 4
Thread-1 9
Thread-2 9
正在运行的线程:  [<_MainThread(MainThread, started 2348)>,
 <MyThread(Thread-1, started 9844)>, <MyThread(Thread-2, started 22792)>]

'''

使用函数方法:

       函数实现方式：线程必须依赖函数实现，不能单独运行。当函数结束，线程结束。所以如果想让线程一直运行，就要想办法让程序不结束，比如在程序最后加一个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


class qiangpiao(threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.setName(name)
    def run(self):
        global  nums,count
        while True:
         
            if nums == 0 :
                return
            nums = nums - 1
            count = count + 1
            print("{0}抢到{1}剩余{2}".format(self.getName(),count,nums))
            time.sleep(0.5)  #建议吧时间加长 不然票都会被第一顺序抢到
       

if __name__ == '__main__' :
    huangniu = qiangpiao('黄牛')
    shouji = qiangpiao('手机')
    chuangkou = qiangpiao('窗口')
    huangniu.start()
    shouji.start()
    chuangkou.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

'''