# 主线程等待所有子线程结束才结束

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方法