多线程-theading

#coding=utf-8
import threading
import time
def saySorry():
    print("亲爱的，我错了，我能吃饭了吗？")
    time.sleep(1)
if __name__ == "__main__":
    for i in range(5):
        t = threading.Thread(target=saySorry)
        t.start() #启动线程，即让线程开始执?

#coding=utf-8
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(1)
if __name__ == ‘__main__‘:
    print(‘---开始---:%s‘%ctime())
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()
    #sleep(5) # 屏蔽此?代码，试试看，程序是否会??结束？
    print(‘---结束---:%s‘%ctime())

    while True:
        length = len(threading.enumerate())
        print(‘当前运?的线程数为：%d‘%length)
        if length<=1:
            break

#coding=utf-8
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) #name属性中保存的是当前线程的名字
            print(msg)
if __name__ == ‘__main__‘:
    t = MyThread()
    t.start()

#coding=utf-8
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()

from threading import Thread
import time
g_num = 100
def work1():
    global g_num
    for i in range(3):
        g_num += 1
    print("----in work1, g_num is %d---"%g_num)
def work2():
    global g_num
    print("----in work2, g_num is %d---"%g_num)
print("---线程创建之前g_num is %d---"%g_num)
t1 = Thread(target=work1)
t1.start()
#延时?会，保证t1线程中的事情做完
time.sleep(1)
t2 = Thread(target=work2)
t2.start()

from threading import Thread
import time
def work1(nums):
    nums.append(44)
    print("----in work1---",nums)
def work2(nums):
    #延时?会，保证t1线程中的事情做完
    time.sleep(1)
    print("----in work2---",nums)
g_nums = [11,22,33]
t1 = Thread(target=work1, args=(g_nums,))
t1.start()
t2 = Thread(target=work2, args=(g_nums,))
t2.start()

运?结果:
----in work1--- [11, 22, 33, 44]
----in work2--- [11, 22, 33, 44]

#创建锁
mutex = threading.Lock()
#锁定
mutex.acquire([blocking])
#释放
mutex.release()

from threading import Thread, Lock
import time
g_num = 0
def test1():
    global g_num
    for i in range(1000000):
        #True表示堵塞 即如果这个锁在上锁之前已经被上锁了，那么这个线程会在这??直等待到解锁为?
        #False表示?堵塞，即不管本次调?能够成功上锁，都不会卡在这,?是继续执?下?的代码
        mutexFlag = mutex.acquire(True)
       if mutexFlag:
            g_num += 1
            mutex.release()
    print("---test1---g_num=%d"%g_num)
def test2():
    global g_num
    for i in range(1000000):
        mutexFlag = mutex.acquire(True) #True表示堵塞
        if mutexFlag:
            g_num += 1
           mutex.release()
        print("---test2---g_num=%d"%g_num)
#创建?个互斥锁
#这个所默认是未上锁的状态
mutex = Lock()
p1 = Thread(target=test1)
p1.start()
p2 = Thread(target=test2)
p2.start()
print("---g_num=%d---"%g_num)

from threading import Thread,Lock
from time import sleep
class Task1(Thread):
    def run(self):
        while True:
            if lock1.acquire():
                print("------Task 1 -----")
                sleep(0.5)
                lock2.release()
class Task2(Thread):
    def run(self):
        while True:
            if lock2.acquire():
                print("------Task 2 -----")
                sleep(0.5)
                lock3.release()
class Task3(Thread):
    def run(self):
        while True:
            if lock3.acquire():
                print("------Task 3 -----")
                sleep(0.5)
                lock1.release()
#使?Lock创建出的锁默认没有“锁上”
lock1 = Lock()
#创建另外?把锁，并且“锁上”
lock2 = Lock()
lock2.acquire()
#创建另外?把锁，并且“锁上”
lock3 = Lock()
lock3.acquire()
t1 = Task1()
t2 = Task2()
t3 = Task3()
t1.start()
t2.start()
t3.start()

?产者消费者模式是通过?个容器来解决?产者和消费者的强耦合问题。?
产者和消费者彼此之间不直接通讯，?通过阻塞队列来进?通讯，所以?产
者?产完数据之后不?等待消费者处理，直接扔给阻塞队列，消费者不找?
产者要数据，?是直接从阻塞队列?取，阻塞队列就相当于?个缓冲区，平
衡了?产者和消费者的处理能?。
这个阻塞队列就是?来给?产者和消费者解耦的。纵观?多数设计模式，都
会找?个第三者出来进?解耦，

import threading
# 创建全局ThreadLocal对象:
local_school = threading.local()
def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print(‘Hello, %s (in %s)‘ % (std, threading.current_thread().name))
def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()
t1 = threading.Thread(target= process_thread, args=(‘dongGe‘,), name=
t2 = threading.Thread(target= process_thread, args=(‘?王‘,), name=
t1.start()
t2.start()
t1.join()
t2.join()