python3 - 多线程 - thre

目录

一、threading 模块：对线程的处理

二、Thread组件

2-1 开启线程的方式一（函数）

2-2 开启线程的方式二 （类）

2-3 Thread 相关内置子方法 

2-4 主进程等待新建线程实例

2-5 线程共用创造进程内资源

2-7 查看线程和‘父’进程的pid

2-8 Thread 实现 “守护线程”

2-8-1 守护线程概念介绍

2-8-2 实现简单 ‘守护线程’

2-9 Thread + Lock 实现线程“互斥锁” 

2-10 Thead + Semaphore 实现 “信号量”

2-11 Thread + Event 实现 “事件”

三、Timer 组件：定时器，n秒后执行操作

---

multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性；

官方链接

2-1 开启线程的方式一（函数）

from threading import Thread
import time


def task(name):
    print('%s is running' % name)
    time.sleep(2)
    print('%s is done' % name)


if __name__ == '__main__':
    t = Thread(target=task, args=('线程1',))
    t.start()
    print('main')

2-2 开启线程的方式二 （类）

from threading import Thread
import time


class Mythread(Thread):

    def run(self):
        print('%s is running' % self.name)
        time.sleep(2)
        print('%s is done' % self.name)


if __name__ == '__main__':
    t = Mythread()
    t.start()
    print('main')

2-3 Thread 相关内置子方法 

• obj.isAlive():返回线程是否为活动状态
• obj.getName():返回线程名
• obj.setName():设置线程名
• threading.currentThread():返回当前的线程变量
• threading.enumerate():返回一个包含正在运行的线程list，即线程启动后、结束前，不包括启动前和终止后的线程。
• threading.actibeCount():返回正在运行的线程数量，同 len ( threading.enumerate ( ) )

from threading import Thread
import threading
from multiprocessing import Process
import os

def work():
    import time
    time.sleep(3)
    print(threading.current_thread().getName())


if __name__ == '__main__':
    #在主进程下开启线程
    t=Thread(target=work)
    t.start()

    print(threading.current_thread().getName())
    print(threading.current_thread()) #主线程
    print(threading.enumerate()) #连同主线程在内有两个运行的线程
    print(threading.active_count())
    print('主线程/主进程')

    '''
    打印结果:
    MainThread
    <_MainThread(MainThread, started 140735268892672)>
    [<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>]
    主线程/主进程
    Thread-1
    '''

2-4 主进程等待新建线程实例

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('eGon',))
    t.start()
    t.join()
    print('主进程')
    print(t.is_alive())

    '''
    >>>egon say hello
    >>>主进程
    >>>False
    '''

2-5 线程共用创造进程内资源

from threading import Thread

n = 100


def task():
    global n
    n = 0


if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    t.join()
    print('主', n)

'''
>>>主 0
'''

 

2-7 查看线程和‘父’进程的pid

from threading import Thread
import os


def task():
    print('%s is running' % os.getpid())


if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print('主', os.getpid())


'''
>>>14488 is running
>>>主 14488
'''

2-8 Thread 实现 “守护线程”

2-8-1 守护线程概念介绍

守护线程：守护线程会等待主进程内，所有非守护线程，全部运行完毕后，才进行销毁。即，等待进程结束。

2-8-2 实现简单 ‘守护线程’

from threading import Thread
import time


def foo():
    print(123)
    time.sleep(1)
    print("end123")


def bar():
    print(456)
    time.sleep(3)
    print("end456")


t1 = Thread(target=foo)
t2 = Thread(target=bar)

t1.daemon = True
t1.start()
t2.start()
print("main-------")

'''
>>>123
>>>456
>>>main-------
>>>end123
>>>end456
'''

2-9 Thread + Lock 实现线程“互斥锁” 

from threading import Thread, Lock
import time

mutex = Lock() # 每个线程内创建一把锁
n = 100


def task():
    global n

    # 加锁操作

    # mutex.acquire()
    # temp = n
    # time.sleep(0.1)
    # n = temp - 1
    # mutex.release()
    
    with mutex:
        temp = n
        time.sleep(0.1)
        n = temp - 1


if __name__ == '__main__':
    t_l = []
    for i in range(100):
        t = Thread(target=task)
        t_l.append(t) # 添加线程对象
        t.start()

    # 等待每一个线程结束
    for t in t_l:
        t.join()
    print(n)

2-10 Thead + Semaphore 实现 “信号量”

• 信号量：保证只有指定数量线程，才能进行连接资源操作。
• Semaphore：内部管理一个计数器，每次调用acquire()时+1，每次release()时-1.保证了每次连接的指定数量。

from threading import Thread,Semaphore
import time,random

sm=Semaphore(5)
#设置信号量允许连接数

def task(name):
    sm.acquire()

    print('%s 正在使用' %name)
    time.sleep(random.randint(1,3))

    sm.release()

if __name__ == '__main__':

    for i in range(20):
        t=Thread(target=task,args=('路人%s' %i,))
        t.start()

2-11 Thread + Event 实现 “事件”

•  事件：设置面向线程的一个信号标志，控制线程的执行
• Event对象
  • 包含一个由线程设置的信号标志，允许线程等待事件发生。
  • 在初始状态下，信号标志为False。
  • 如果存在线程等待Event对象，则Event对象的标志为False，线程将被阻塞至对象标志改变为True。
  • 如果一个线程等待一个标志为True的Event对象，那么线程将忽略此事件对象，继续执行。
• Event对象内部方法
  • event.isSet():返回event的状态
  • event.wait():如果状态值==False，将阻塞线程
  • event.set():如果event的状态值为True，所有阻塞池的线程激活进入就绪状态，等待操作系统调度
  • event.clear():回复envent的状态为False

from threading import Thread,Event
import time

event=Event()

def light():
    print('红灯正亮着')
    time.sleep(3)
    event.set() #绿灯亮

def car(name):
    print('车%s正在等绿灯' %name)
    event.wait() #等灯绿
    print('车%s通行' %name)

if __name__ == '__main__':
    # 红绿灯
    t1=Thread(target=light)
    t1.start()
    # 车
    for i in range(10):
        t=Thread(target=car,args=(i,))
        t.start()

from threading import Timer
 
 
def hello():
    print("hello, world")
 
t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed