线程_threading合集

# 主线程等待所有子线程结束才结束
import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print("正在唱歌---%d"%(i))
        sleep(2)
def dance():
    for i in range(3):
        print("正在跳舞---%d" % (i))
        sleep(2)
if __name__ == ‘__main__‘:
    print("----开始----%s"%(ctime()))
    t_sing = threading.Thread(target=sing)
    t_dance = threading.Thread(target=dance)
    t_sing.start()
    t_dance.start()
    print("----结束----%s"%(ctime()))

#查看线程数量
import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print("正在唱歌---%d"%i)
        sleep(1)
def dance():
    for i in range(3):
        print("正在跳舞---%d"%i)
        sleep(i)
if __name__ == ‘__main__‘:
    t_sing = threading.Thread(target=sing)
    t_dance = threading.Thread(target=dance)
    t_sing.start()
    t_dance.start()
    while True:
        length = len(threading.enumerate())
        print("当前运行的线程数为:%d"%(length))
        if length<= 1:
            break
        sleep(0.5)

import threading
import time

class MyThread(threading.Thread):
    # 重写 构造方法
    def __init__(self, num, sleepTime):
        threading.Thread.__init__(self)
        self.num = num
        # 类实例不同，num值不同
        self.sleepTime = sleepTime

    def run(self):
        self.num += 1
        time.sleep(self.sleepTime)
        print(‘线程(%s),num=%d‘ % (self.name, self.num))

if __name__ == ‘__main__‘:
    mutex = threading.Lock()
    t1 = MyThread(100, 3)
    t1.start()
    t2 = MyThread(200, 1)
    t2.start()

import threading
from time import sleep

g_num = 1

def test(sleepTime):
    num = 1 #num为局部变量
    sleep(sleepTime)
    num += 1
    global g_num #g_num为全局变量
    g_num += 1
    print(‘---(%s)--num=%d  --g_num=%d‘ % (threading.current_thread(), num,g_num))

t1 = threading.Thread(target=test, args=(3,))
t2 = threading.Thread(target=test, args=(1,))

t1.start()
t2.start()

import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        if mutexA.acquire():
            print("A上锁了")
            mutexA.release()
            time.sleep(2)
            if mutexB.acquire():
                print("B上锁了")
                mutexB.release()
            mutexA.release()

class MyThread2(threading.Thread):
    def run(self):
        if mutexB.acquire():
            print("B上锁了")
            mutexB.release()
            time.sleep(2)
            if mutexA.acquire():
                print("A上锁了")
                mutexA.release()
            mutexB.release()
# 先看B是否上锁，然后看A是否上锁
mutexA = threading.Lock()
mutexB = threading.Lock()

if __name__ == "__main__":
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

多线程threading的执行顺序(不确定)

# 只能保证都执行run函数，不能保证执行顺序和开始顺序
import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I‘m "+self.name+‘ @ ‘+str(i)
            print(msg)
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == ‘__main__‘:
    test()

多线程threading的注意点

import threading
import time

class MyThread(threading.Thread):
    # 重写threading.Thread类中的run方法
    def run(self):
        for i in range(3):#开始线程之后循环三次
            time.sleep(1)
            msg = "I‘m "+self.name+‘@‘+str(i)
            # name属性是当前线程的名字
            print(msg)
if __name__ == ‘__main__‘:
    t = MyThread()#使用threading.Thread的继承类
    t.start()#继承线程之后要开始运行 start方法