Python线程

#<<<<线程的引入背景
#之前我们已经了解了操作系统中进程的概念,程序并不能单独运行,只有将程序卸载到内存
#系统为它分配资源才能运行,而这种执行的程序就称为进程.程序和进程的区别就在于:
#程序是指令的集合,它是进程运行的静态描述文本,进程是程序的一次执行活动,属于动态概念
#在多道编程中,我们允许多个程序同时加载到内存中,在操作系统的调度下,可以实现并发地执行.这是这样设计
#大大提高了CPU的利用率.进程的出现让每个用户感觉到自己独享CPU,因此,进程就是为了
#在cpu上实现多道编程而提出的


#有了进程为什么要有线程?
    #进程有很多优点,它提供了多道编程,让我们感觉我们每个人都拥有自己的CPU和其他资源
#可以提高计算机的利用率.很多人就不理解了,既然进程这么优秀,为什么还要线程呢?其实,仔细观察就会
#发现进程还是有很多缺陷,主要体现在两点上:
    #1.进程只能在一个时间干一件事情,如果想同时干两件事或者多件事,进程就无能为力了
    #2.进程在执行过程中如果阻塞,例如等待输入,整个进程就会挂起,即使进程中有些
        #工作不依赖于输入数据,也将无法执行

    #如果这两个缺点理解比较困难的话,举个实现的例子也许就清除了:如果把我们上课的过程
#看成一个进程的话,那么我们要做的试试耳朵听老师讲课,手上还要记笔记,脑子还要思考问题,
#这样才能高效的完成听课任务.而如果值提供进程这个机制的话,也不能用脑子思考,这是其一
#如果老师在黑板演算过程,我们开始记笔记,而老师突然有一步推不下去了,阻塞住了,他在边思考,er
#学生呢,也不能干其它事,即使你想趁机此时思考一下刚才没听懂的一个问题都不行,这是其二
    #现在你应该明白了进程的缺陷,而解决的办法也很简单,我们完全可以让听,写,思考三个独立
#并行起来,这样很明显可以提高听课的效率.而实际的操作系统中,也同样引入了这样类似的机制-进程

            # 进程的出现
    #60年代,在os中能拥有资源和独立运行的基本单位是进程,然而随着计算机技术的发展,进程
#出现了很多弊端,一是由于进程是资源拥有者,创建,撤销与切换存在较大的时空开销,因而需要引
#入轻型进程.二是由于对称多处理机(SMP)出现,可以满足多个运行单位,而多个进程并行开销过大
    #因此在80年代,出现了能独立运行的基本单位,线程(Threads)
    #注意:
        # 进程是资源分配的最小单位,线程是CPU调度的最下单位
        # 每一个进程中至少有一个线程

#线程和进程的区别:
    # 1.地址空间和其他资源(如打开文件):进程间相互独立,同一进程的各线程间共享.某进程内的
        #线程在其他进程不可见
    # 2.通信:进程间通信IPC,线程间可以直接读写进程数据段(如全局变量)来进行通信
        #需要进程同步和互斥手段的辅助,可以保证数据的一致性
    # 3.调度和切换:线程上下文切换比进程上下文切换要快的多
    # 4.在多线程操作系统中,进程不是一个可执行的实体

# 线程的特点
    #在多线程的操作系统中,通常是一个进程中包括多个线程,每个线程都是作为CPU的基本单位
#是花费最小开销的实体.线程具有以下属性.
    # 1.轻型实体
        #线程中的实体基本上不拥有系统资源,只是有一点必不可少的,能够保证独立运行的资源
        #线程是实体包括程序,数据和TCB.线程是动态概念,它的动态性由线程控制TCB描述
            #TCB包含以下信息:
                # 1).线程状态
                # 2).当线程不运行时,被保存的现场资源
                # 3).一组执行堆栈
                # 4).存放每个线程的局部变量主存区
                # 5).访问同一个进程的主存和其它资源.
            #用于指示被执行指令序列的程序计数器,保留局部变量,少数状态参数和返回地址
            #等的一组寄存器和堆栈

    # 2.独立调度和分派的基本单位.
        #在多线程OS中,线程是独立运行的基本单位,因而也是独立调度和分派的基本单位.由于
    #线程很"轻",故线程的切换非常迅速且开销小(在同一进程中)

    # 3.共享进程资源
        #线程在同一进程中的各个线程,都可以共享该进程所拥有的资源,这首先表现在:所有线程都具有
    #的进程id,这意味着,线程可以访问该进程的每一个资源.此外,还可以访问进程所拥有的已打开
    #文件,定时器,信号量机构等.由于同一个进程内的线程共享内存和文件,所以线程之间互相通信不必
    #调用内核.

    # 4.可并发执行
        #在一个进程中的多个线程之间,可以并发执行,甚至允许在一个进程中所有线程都能并发
    #执行.同样,不同进程中的线程也能并发执行,充分利用和发挥了处理机与外围设备并行工作的能力

# 使用线程的实际场景
    #开启一个子处理软件进程,该进程肯定需要办不止一件事件,比如监听键盘输入,处理文字,定时
#自动将文字保存到硬盘,这三个任务操作的都是同一块数据,因而不能用多进程.只能在一个进程里并发
#地开启三个进程.如果是单线程,那就只能是,键盘输入时,不能处理文字和自动保存,自动保存时又不能
#输入和处理文字


    #多个线程共享同一个进程的地址空间中的资源,是对一台计算机上多个进程的模拟,有时也
#称线程为轻量级的进程
    #而对一台计算机上多个进程,则共享物理内存,磁盘,打印机等其它物理资源.多线程的运行也
#多进程类似,是cpu在多个线程之间快速的切换.
    #不同进程之间是重名敌意的,彼此是抢占,竞争cpu的关系,如果迅雷和QQ抢占资源.而同一个
#进程是由一个程序员的程序创建,所以同一进程内的线程是合作关系,一个进程可以访问另外一个
#线程的内存地址,大家都是可以共享的.
    #类似于进程,每个线程也有自己的推栈,不同于进程,线程库无法利用时钟中断强制线程
#让出CPU,可以调用thread_yield运行线程自动放弃cpu,让另外一个线程运行.
    #线程通常是有益的,但是带来了不小程序设计难度,线程的问题是:
        # 1.父进程有多个线程,那么开启的子进程是否需要同样多的线程
        # 2.在同一个进程中,如果一个线程关闭了文件,而另外一个线程正准备往该文件写入文件呢
        #  因此,在多线程的代码中,需要更多的心思来设计程序的逻辑,保护程序的数据

#  用户级线程和内核级线程
    #线程的实现可以分为两类:用户级线程和内核线线程,或者又称为内核支持的线程或轻量级进程
#在多线程操作系统中,各个系统的实现方式并不相同,在有的系统中实现了用户级线程,有系统中
#实现了内核级线程
    #用户级线程:内核的切换由用户态程序自己控制内核切换,不需要内核干涉,少了进出内核态的消耗
#但是不能很好的利用多核CPU.
    #内核级线程:切换由内核控制,当线程进行切换的时候,由用户态转化为内核态.切换完毕
#要从内核态返回用户态,可以很好的利用smp,既利用多核cpu.windows线程就是这样.


#   线程和Python
# 全局解释器锁GIL
    # Python代码的执行由Python虚拟机(解释器主循环)来控制.Python在设计之初就考虑到要在主循环中
#同时只有一个线程在执行.虽然Python解释器中可以运行多个进程,但在任意时刻只有一个线程在
#解释器中运行.对Python虚拟机的访问由全局解释器锁(GIL)来控制,正是这个锁能保证同一时刻
#只有一个线程在运行.
    #在多线程环境中,Python虚拟机按以下方式执行:
    # 1.设置GIL
    # 2.切换到一个线程去运行
    # 3.运行指定数量的字节码指令或者主动让出控制(可以调用time.sleep(0)
    # 4.把线程设置为睡眠状态
    # 5.解锁GIL
    # 6.再次重复以上步骤
    # 注意:在调用外部代码,GIL将会被锁定,直到这个函数结束为止.

#  Python线程模块的选择
    #Python提供了几个用于多线程编程的模块,包括thread,threading和Queue.
#thread和threading模块允许程序员创建和管理线程.thread模块提供了基本的线程和锁的支持,threading
#提供了更高级别,功能更强的线程管理的功能.Queue模块允许用户创建一个可以用于多个线程之间共享数据
#的队列数据结构.
    #避免使用thraed模块,因为更高级别的threading模块更为先进,对线程的支持更为完善
#而且使用thread模块里属性有可能会与threading出现冲突;其次低级别的thread模块的同步原语
#很少,而threading模块则很多;再者,thread模块中当主线程结束时,所有的线程都会被强制结束掉
#没有警告也不会有正常的清除工作,至少threading模块能确保重要的子线程退出后线程才退出
#
#    threading模块
# multiprocessing模块是完全模仿了threading模块的接口,二者在使用层面,有很大的相似性

#   线程的创建Threaing.Thread类

#  普通开启一个线程
# from threading import Thread
# import time
#
# def func(name):
#     time.sleep(2)
#     print(‘%s在吃饭‘%name)
#
# if __name__ == ‘__main__‘:
#     t = Thread(target=func,args=("alex",))
#     t.start()
#     print("主线程")

#通过继承开启一个线程

# from threading import Thread
# import time
# class MyThread(Thread):
#     def __init__(self):
#         super(MyThread, self).__init__()
#     def run(self):
#         time.sleep(2)
#         print("这是子线程")
# if __name__ == ‘__main__‘:
#     t = MyThread()
#     t.start()  #  start直接调用run方法
#     print("这是主进程")


#  多进程和多进程
#  pid比较

# from multiprocessing import Process
# from threading import Thread
# import time,os
#
# def func1():
#     print("子进程的pid是%s" %os.getpid())
#
# def func2():
#     print("子线程的pid是%s" %os.getpid())
#
# if __name__ == ‘__main__‘:
#     # 在主进程开启多个子进程
#     p1 = Process(target=func1)
#     p2 = Process(target=func1)
#     p1.start()
#     p2.start()
#     print("主进程的pid是%s" %os.getpid())
#
#
#     # 在主线程开启多个子线程
#     t1 = Thread(target=func2)
#     t2 = Thread(target=func2)
#     t1.start()
#     t2.start()
#     print(‘主线程的pid是%s‘ %os.getpid())


#结果:   子进程的pid和主进程pid不相同,子线程的pid和主线程的pid都是相同
# 主进程的pid是3336
# 子线程的pid是3336
# 子线程的pid是3336
# 主线程的pid是3336
# 子进程的pid是9840
# 子进程的pid是7852

#进程和线程开启效率的对比

# from multiprocessing import Process
# from threading import Thread
# import time
#
# def func():
#     pass
#
# if __name__ == ‘__main__‘:
#     # 开启进程
#     start = time.time()
#     for i in range(100):
#         p = Process(target=func)
#         p.start()
#     print(‘开启100个现成的时间:‘,time.time() - start)

    #开启线程
    # start = time.time()
    # for i in range(100):
    #     t = Thread(target=func)
    #     t.start()
    # print(‘开启100个线程的时间:‘,time.time() - start)

#结果:  开启效率线程比进程块
# 开启100个现成的时间: 4.052232027053833
# 开启100个线程的时间: 0.21401238441467285

#  Thread的其他方法

# Thread实例对象的方法

# isAlive():返回线程是否活动的
# getName():返回线程名
# setName():返回线程名

#  threading模块提供的一些方法:
    # threading.currentThread():返回当前的线程变量
    # threading.enumerate():返回一个包含正在运行的线程list.正在运行指线程启动
    #结束前,不包括启动前和终止后的线程
    # threading.activeCount():返回正在运行的线程数量,与len(threading.enumeratr())有相同的结果

# from threading import Thread
# import threading
# from multiprocessing import Process
# import os,time
#
# def func():
#     time.sleep(3)
#     print(threading.current_thread().getName())
#
#
# if __name__ == ‘__main__‘:
#     # 在主进程下开启线程
#     t = Thread(target=func)
#     t.start()
#     print(threading.current_thread().getName())
#     print(threading.current_thread())   #  主线程
#     print(threading.enumerate())        # 连同主线程在内有两个运行的线程
#     print(threading.active_count())
#     print(‘主进程/主线程‘)

# 结果:
# MainThread
# <_MainThread(MainThread, started 8280)>
# [<_MainThread(MainThread, started 8280)>, <Thread(Thread-1, started 3212)>]
# 2
# 主进程/主线程
# Thread-1



#  join 方法


# from threading import Thread
# import time
# def func():
#     time.sleep(2)
#     print(‘睡觉‘)
#
# if __name__ == ‘__main__‘:
#     t = Thread(target=func)
#     t.start()
#     t.join()  #  等待子线程先执行,子线程结束后执行主进程
#     print("主线程")
#     print(t.is_alive())

#  结果:
# 睡觉
# 主线程
# False


# 守护线程
# 无论是进程还是线程,都遵循:守护xx会等待主xx运行完毕后被销毁.需要强调的是:运行完毕并非终止运行
# 1.对主进程来说,运行完毕指的是主进程代码运行完毕
# 2.对主线程来说,运行完毕指的是主线程内所有的进程内所有非守护全部运行完毕,主进程才算运行完毕

# 具体解释:
    # 1.主进程在其代码结束后就已经算运行完毕(守护进程在此时就被回收),然后主进程会一直非守护的子进程都
#运行完毕后回收子进程的资源(否者会产生僵死进程),才会结束.
    # 2.主线程在其它非守护线程运行完毕后才算运行完毕(守护线程在此时就被回收).因为主线程
    #的结束意味着进程的结束,进程整体的资源都将被回收,而进程必须保证非守护线程都运行完毕后才能结束

# from threading import Thread
# import time
# def func1():
#     time.sleep(3)
#     print("睡觉")
# def func2():
#     time.sleep(2)
#     print("吃饭")
# if __name__ == ‘__main__‘:
#     t = Thread(target=func1)
#     t.daemon = True  #  守护线程必须在start之前
#     t.start()
#     time.sleep(3)
#     t1 = Thread(target=func2)    #  普通线程
#     t1.start()
#     print("主线程")
#     print(t.is_alive())
#     print(t1.is_alive())

    # 守护线程是随着主线程执行结束而结束
    # 守护线程不是根据主线程的代码执行结束而结束
    # 主线程要等普通线程结束才结束
    # 所以,一般把不重要的事情设置为守护线程

#结果:
# 睡觉
# 主线程
# False
# True
# 吃饭


#  验证守护进程

# from multiprocessing import Process
# import time
# def func1():
#     time.sleep(2)
#     print("睡觉")
#
# def func2():
#     time.sleep(1)
#     print("吃饭")
# if __name__ == ‘__main__‘:
#     p = Process(target=func1)
#     p.daemon = True    # 守护进程
#     p.start()
#     p1 = Process(target=func2)
#     p1.start()
#     print(‘主进程‘)
#     print(p.is_alive())

#  守护进程是随着主进程代码块结束而结束.



#  锁
#锁和GIL
#同步锁
#  在多用户抢占资源的情况下

# from threading import Thread
# import time,os
#
# def func():
#     global n  # 定义全局变量
#     temp = n
#     time.sleep(0.1)
#     n = temp - 1
#     #print(n)
# if __name__ == ‘__main__‘:
#     n = 100
#     lst = []
#     for i in range(100):
#         t = Thread(target=func)
#         lst.append(t)
#         t.start()
#     [t.join() for t in lst]
#     print(n)
# 结果为 99

#  同步锁的引用:
# from threading import Thread,Lock
# import os,time
# def func(l):
#     global n
#     l.acquire()  #  上锁
#     temp = n
#     time.sleep(0.1)
#     n = temp - 1
#     l.release()
#
# if __name__ == ‘__main__‘:
#     l = Lock()
#     n = 100
#     lst = []
#     for i in range(100):
#         t = Thread(target=func,args=(l,))
#         lst.append(t)
#         t.start()
#     [t.join() for t in lst]
#     print(n)  # 结果是0 由原来的并发执行变成串行,牺牲了执行效率保证了数据安全


 #  互斥锁和join的区别

# 不加锁:并发执行,速度快,数据不安全
# from threading import Thread,Lock,current_thread
# import time,os
#
# def func():
#     global n
#     print(‘%s is running‘ %current_thread().getName())
#     temp = n
#     time.sleep(0.5)
#     n = temp -1
#
# if __name__ == ‘__main__‘:
#     n = 100
#     lst = []
#     start = time.time()
#     for i in range(100):
#         t = Thread(target=func)
#         lst.append(t)
#         t.start()
#     [t.join() for t in lst]
#     print(‘主:%s n:%s‘ %(time.time() - start,n))

#  结果:
# Thread-1 is running
# Thread-2 is running
#.......
# Thread-99 is running
# Thread-100 is running
# 主:0.5100293159484863 n:99
#

#  不加锁:未加锁部分并发执行,加锁部分串行,速度慢,数据安全
# from threading import current_thread,Thread,Lock
# import os,time
#
# def func():
#     #未加锁代码并发执行
#     time.sleep(4)
#     print("%s start to run" %current_thread().getName())
#     global n
#     # 加锁的代码串行运行
#     lock.acquire()
#     temp = n
#     time.sleep(0.5)
#     n = temp -1
#     lock.release
#
# if __name__ == ‘__main__‘:
#     n = 100
#     lock = Lock()
#     lst = []
#     start = time.time()
#     for i in range(100):
#         t = Thread(target=func)
#         lst.append(t)
#         t.start()
#     for t in lst:
#         t.join()
#     print("主:%s n:%s" %(time.time() - start,n))
#


#  死锁和递归锁
# 死锁:是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象
#诺无外力作用,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些
#在相互等待的进程称为死锁进程
# 死锁代码:
# from threading import Lock
# import time
# muteAx = Lock()
# muteAx.acquire()
# muteAx.acquire()
# print(123)
# muteAx.release()
# muteAx.release()
# #  程序死锁等待
#解决方法,递归锁,在Python中为了支持在同一线程中多次请求同一资源,python提供
#了可以重入锁RLock
# 这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,conger
#使得资源可以多次release.直到一个线程所有的acquire都被release,其他的线程才能获得资源

#  改进版

# from threading import RLock
# import time
# muteAx = RLock()
# muteAx.acquire()
# muteAx.acquire()
# print(123)
# muteAx.release()
# muteAx.release()

# 结果:123

#  典型问题,科学家吃面问题

# from threading import Thread ,Lock
# import time
# noodle_lock = Lock()
# fork_lock = Lock()
#
# def eat1(name):
#     noodle_lock.acquire()
#     print("%s抢到面条" %name)
#     fork_lock.acquire()
#     print(‘%s抢到叉子‘%name)
#     print(‘%s吃面‘%name)
#     fork_lock.release()
#     noodle_lock.release()
#
# def eat2(name):
#     fork_lock.acquire()
#     print(‘%s抢到叉子‘%name)
#     time.sleep(1)
#     noodle_lock.acquire()
#     print("%s抢到面条"%name)
#     print(‘%s吃面‘%name)
#     noodle_lock.release()
#     fork_lock.release()
#
# for name in [‘哪吒‘,‘egon‘,‘yuan‘]:
#     t1 = Thread(target=eat1,args=(name,))
#     t2 = Thread(target=eat2,args=(name,))
#     t1.start()
#     t2.start()
# 结果:程序卡住

#  解决递归死锁问题

# from threading import Thread,RLock
# import time
# fork_lock = noodle_lock = RLock()
#
# def eat1(name):
#     noodle_lock.acquire()
#     print("%s抢到面条了"%name)
#     fork_lock.acquire()
#     print("%s抢到了叉子"%name)
#     print(‘%s吃面‘%name)
#     fork_lock.release()  # 还叉子
#     noodle_lock.release() #   还面
#
# def eat2(name):
#     fork_lock.acquire()
#     print("%s抢到叉子"%name)
#     time.sleep(1)
#     noodle_lock.acquire()
#     print(‘%s抢到面条‘%name)
#     print(‘%s吃面‘%name)
#
# for name in [‘哪吒‘,‘alex‘,‘太白‘]:
#     t1 = Thread(target=eat1,args=(name,))
#
#     t2 = Thread(target=eat2,args=(name,))
#     t1.start()
#     t2.start()



#  信号量
#同进程的一样
#Semaphore管理一个内置的计数器
#每当调用acquire()时内置计算器-1
#调用release()时内置计数器+1
#计数器不能小于0,当计数器为0时,acquire()将阻塞线程直到其他线程调用release()
#实例:同时只有5个线程可以获得Semaphore即可以限制最大连接数为5个



# from threading import Thread,Semaphore
# import threading,time
#
# def func():
#     sm.acquire()
#     print(‘%s get sm‘%threading.current_thread().getName())
#     time.sleep(3)
#     sm.release()
#
# if __name__ == ‘__main__‘:
#     sm = Semaphore(5)
#     for i in range(10):
#         t = Thread(target=func)
#         t.start()


#  事件
#和进程的一样
#线程的一个关键性是每个线程都是独立运行且状态不可预测.如果程序中有其它线程需通过判断某个线程
#的状态来确定自己下一步操作,这时线程同步问题就会变的非常棘手.为了解决这些问题,我们需要
#使用threading库中的Event对象.对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的
#发生.在初始情况下Event对象中的信号标志被设置为假.如果有线程等待一个Event对象,而这个Event
#Event对象的标志为假,那么这个线程会被一直阻塞直到标志为真.一个线程如果将一个Event对象的
#信号标志设置为真,它将唤醒所有等待这个Event对象的线程.如果一个线程等待一个已经被设置为真
#的Event对象,那么它将忽略这个事件,继续执行

# event.isSet(): 返回Event的状态值
# event.wait():如果event.isSet()==False将阻塞线程
# event.set():设置event的状态值为True,所有阻塞池的线程激活进入就绪状态,等待操作系统调度
#
# event.clear():恢复event的状态值为False
#
#例如 有很多个工作线程尝试连接MySQL,我们想要在连接前确保MySQL服务正常才让那些工作线程去
#连接MySQL服务器,如果连接不成功,都会尝试重新连接.那么我们就可以采用htreading.Event机制
#来协调各个工作线程的连接操作

# from threading import Thread,Event
# import threading,time,random
#
# def conn_mysql():  #  连接服务器
#     count = 1
#     while not event.is_set():
#         if count > 3:
#             raise TimeoutError(‘链接超时‘)
#         print(‘<%s>第%s次尝试链接‘%(threading.current_thread().getName(),count))
#         event.wait(0.5)
#         count += 1
#     print("<%s>链接成功"%threading.current_thread().getName())
#
#
# def check_mysql():
#     print("\033[32m[%s]正在检查mysql\033[0m"%threading.current_thread().getName())
#     time.sleep(random.randint(1,3))
#     event.set()
#
#
# if __name__ == ‘__main__‘:
#     event = Event()
#     conn1 = Thread(target=conn_mysql)
#     conn2 = Thread(target=conn_mysql)
#     check = Thread(target=check_mysql())
#     conn1.start()
#     conn2.start()
#     check.start()
#
#


#  条件

#使得线程等待,只有满足条件时,才释放n个线程
#Python提供的Condition对象提供了对复杂线程同步问题的支持Condition被称为条件变量,除了
#提供与Lock类似的acquire和release方法外,还提供了wait和notify方法.线程首先acquire一个条件变量
#然后判断一些条件.如果条件不满足则wait,如果条件满足,进行一些处理改变条件后,通过notify方法通知
# 其他线程,其它处于wait状态的线程接到通知后会重新判断条件.不断的重复这一过程,从而解决复杂的问题

# from threading import Thread,Condition
#
# def run(n):
#     con.acquire()
#     con.wait()
#     print(‘run the thread:%s‘%n)
#     con.release()
#
# if __name__ == ‘__main__‘:
#     con = Condition()
#     for i in range(10):
#         t = Thread(target=run,args=(i,))
#         t.start()
#     while 1:
#         inp = input(">>>>")
#         if inp.upper() == "Q":
#             break
#         con.acquire()
#         con.notify(int(inp))
#         con.release()
#         print("****")

#   定时器

# 定时器,指定n秒后执行某个操作
# from threading import Timer
# Timer(time,func)
# time：睡眠的时间，以秒为单位
# func：睡眠时间之后，需要执行的任务

from threading import Timer

def hello():
    print(‘hello,world‘)

t = Timer(5,hello)    #  警示定时5秒执行函数hello
t.start()