1.线程，线程创建

　　概念：在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程，线程顾名思义，就是一条流水线工作的过程，一条流水线必须属于一个车间，一个车间的工作过程是一个进程，车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一个流水线。流水线的工作需要电源，电源就相当于cpu。

　　所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。

　　多线程（即多个控制线程）的概念是，在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。

 

　　创建：

　　线程创建方式一：

from multiprocessing import Process
from threading import Thread


def func(n):
    print('xxxxx')
    print('>>>',n)


if __name__ == '__main__':

    # p = Process(target=func,args=(1,))
    # p.start()

    t = Thread(target=func,args=(1,))  # 直接创建
    t.start()

    print('主线程结束')

　　面向对象创建：

from threading import Thread


# 面向对象创建
class Mythread(Thread):  # 继承Thread父类

    def __init__(self,xx):
        super().__init__()
        self.xx = xx

    def run(self):  # 必须有run,覆盖父类run中的pass
        print(self.xx)
        print('我重置父类方法')

    def func1(self): # 写其他方法
        print('我是func1')


if __name__ == '__main__':

    t1 = Mythread('xx')
    t1.start()  # 默认执行run
    t1.func1()  # 调用其他方法
#

from multiprocessing import Process
from threading import Thread

 

 

2.Thread类方法

　　join方法：

　　主线程等待join子线程执行完毕后才执行

import time
from threading import Thread


def func(n):
    time.sleep(n)
    print('我是子线程')


if __name__ == '__main__':

    t = Thread(target=func,args=(1,))
    t.start()

    t.join() # 等待子线程执行结束
    print('我是主线程，子线程结束再执行我')

　　

　　其他方法：

''
Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

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

import time, threading
from threading import Thread, current_thread


def func():
    time.sleep(2)
    print('子线程,名字是：', current_thread().getName())  # 返回线程名
    print('子线程，ID是：', current_thread().ident)  # 返回线程id


if __name__ == '__main__':

    for i in range(10):
        t = Thread(target=func, )
        t.start()

    print(threading.enumerate())  # 返回一个包含正在运行的list
    print(threading.activeCount())  # 返回正在运行的线程数量，等同len(threading.enumerate())

    print('主线程结束')

 

 

3.守护线程、事件

　　守护线程：

　　主进程结束，守护进程跟着结束，再执行非守护进程
　　主线程要等待所有非守护线程运行结束才会结束(因为他们属于同一进程)
　　需注意：运行结束并非终止运行

　　xxx.setDaemon(True)  或者 xxx.daemon = True

import time
from threading import Thread
from multiprocessing import Process


def func1():
    time.sleep(3)
    print('任务1结束')


def func2():
    time.sleep(2)
    print('任务2结束')


if __name__ == '__main__':

    # p1 = Process(target=func1,)
    # p2 = Process(target=func2,)
    # # p1.daemon = True
    # p2.daemon = True
    # p1.start()
    # p2.start()
    #
    # print('主进程结束')

    t1 = Thread(target=func1,)
    t2 = Thread(target=func2,)
    # t1.setDaemon(True) # 只打印出 主线程和t2 因为t2时间比t1小
    t2.setDaemon(True)  # 会正常打印出所有 因为t1时间大于t2
    t1.start()
    t2.start()

    print('主线程结束')

　　

　　事件:　

　　event.isSet()：返回event的状态值；
　　event.wait()：如果 event.isSet()==False将阻塞线程；
　　event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；
　　event.clear()：恢复event的状态值为False。

import time
from threading import Event

e = Event()  # 默认false状态
p