1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import threading
import time

class MyThread(threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print("start thread:"+self.name)
        self.MyJob()
        print("exit thread:"+self.name)
        pass
    def MyJob(self):
        while self.counter:
            time.sleep(1)    # 1s
            print("%s,%s" % (self.name, time.ctime(time.time()) ))
            self.counter -= 1
        pass

1
2
3
4
thread = MyThread(1, "hello", 6) 
thread.start()
thread.join()
print("exit main thread")

1
2
3
4
5
6
7
8
9
10
11
12
import threading
import time
def MyJob(name, counter):
    while counter:
        time.sleep(1)    # 1s
        print("%s,%s" % (name, time.ctime(time.time()) ))
        counter -= 1
    pass

mythread = threading.Thread(target=MyJob, args=('hello', 4))
mythread.start()
mythread.join()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import threading
import time

number = 0
lock = threading.Lock()  # 实例化一个互斥锁

def plus(lk):
    global number       # global声明此处的number指的就是外面的全局变量number
    lk.acquire()        # 开始加锁
    for _ in range(1000000):    # 进行一个大数级别的循环加一运算
        number += 1
    print("子线程%s运算结束后，number = %s" % (threading.current_thread().getName(), number))
    lk.release()        # 释放锁，让别的线程也可以访问number

if __name__ == '__main__':
    threads = []
    for i in range(2):      # 用2个子线程，就可以观察到脏数据
        t = threading.Thread(target=plus, args=(lock,)) # 需要把锁当做参数传递给plus函数
        t.start()
        threads.append(t)
    for i in threads:
        i.join()
    print("主线程执行完毕后，number = ", number)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import threading
import time

def MyJob(name, counter, delay, se):
    se.acquire()
    while counter:
        time.sleep(delay)    # 1s
        print("%s,%s" % (name, time.ctime(time.time()) ))
        counter -= 1
    se.release()
    pass

se = threading.BoundedSemaphore(2)   # 创建一个信号量锁，运行同时发两把钥匙

mythread1 = threading.Thread(target=MyJob, args=('thread1', 8, 1, se))
mythread2 = threading.Thread(target=MyJob, args=('thread2', 3, 2, se))
mythread1.start()
mythread2.start()
mythread1.join()
mythread2.join()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import threading
import time

event_green_light_on = threading.Event()
running = False

def lighter():
    green_time = 3       # 绿灯时间
    red_time = 2         # 红灯时间
    event_green_light_on.set()          # 初始设为绿灯
    while running:
        print("绿灯亮...")
        time.sleep(green_time)
        event_green_light_on.clear()
        print("红灯亮...")
        time.sleep(red_time)
        event_green_light_on.set()
    print("红绿灯线程退出")
    pass
    
def Cars(name):
    while running:
        if event_green_light_on.is_set():      # 判断当前是否"放行"状态
            print("一辆[%s] 呼啸开过..." % name)
            time.sleep(0.5)
        else:
            print("一辆[%s]开来，看到红灯，无奈的停下了..." % name)
            event_green_light_on.wait()         # 程序阻塞，等待事件
            print("[%s] 看到绿灯亮了，瞬间飞起....." % name)
    print("汽车线程退出")
    pass
    
if __name__ == '__main__':
    running = True
    light = threading.Thread(target=lighter,)
    light.start()
    for name in ['奔驰', '宝马', '奥迪']:
        car = threading.Thread(target=Cars, args=(name,))
        car.start()
    time.sleep(10)
    running = False
    if light.isAlive():
        light.join()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import threading
import time

num = 0
con = threading.Condition()  # 设置一个条件
running = True

class Foo(threading.Thread):
    
    def __init__(self, name, action):
        super(Foo, self).__init__()
        self.name = name
        self.action = action

    def run(self):
        global num
        con.acquire()            # 获取锁
        print("%s开始执行..." % self.name)
        while running:
            if self.action == "add":
                num += 1
            elif self.action == 'reduce':
                num -= 1
            else:
                exit(1)
            print("num当前为：", num)
            time.sleep(1)
            if num == 5 or num == 0:
                print("暂停执行%s！" % self.name)
                con.notify()   # 通知
                con.wait()     # 等待
                print("%s开始执行..." % self.name)
        con.release() #　释放锁
        pass

if __name__ == '__main__':
    a = Foo("线程A", 'add')
    b = Foo("线程B", 'reduce')
    a.start()
    b.start()
    time.sleep(12)
    running = False
    if a.isAlive():
        con.notify()  
        a.join()
    if b.isAlive():
        con.notify()  
        b.join()

1
2
3
4
5
6
7
from threading import Timer

def hello():
    print("hello. world")
    
t = Timer(3, hello)
t.start()

1
2
3
with some_lock:
    # do something 
    pass

1
2
3
4
5
6
# 也相当于
some_lock.acquire()
try:
    # 执行任务..
finally:
    some_lock.release()