import threading
import time

def run(name, s): # 线程要执行的任务
 time.sleep(s) # 停两秒
 print('I am %s' % name)

# 实例化线程类, 并传入函数及其参数, 
t1 = threading.Thread(target=run, name='one', args=('One', 5))
t2 = threading.Thread(target=run, name='two', args=('Two', 2))

# 开始执行, 这两个线程会同步执行
t1.start()
t2.start()
print(t1.getName())		# 获取线程名
print(t2.getName())

# Result:
one
two
I am Two	# 运行2s后
I am One	# 运行5s后

class MyThread(threading.Thread): # 继承threading中的Thread类
 # 线程所需的参数
 def __init__(self, name, second):
 super().__init__()
 self.name = name
 self.second = second

 # 重写run方法,表示线程所执行的任务,必须有
 def run(self):
 time.sleep(self.second)
 print('I am %s' % self.name)
# 创建线程实例
t1 = MyThread('One', 5)
t2 = MyThread('Two', 2)
# 启动线程,实际上是调用了类中的run方法
t1.start()
t2.start()
t1.join()
print(t1.getName())
print(t2.getName())

# Result:
I am Two	# 运行后2s
I am One	# 运行后5s
One
Two

# 开始执行, 这两个线程会同步执行
t1.start()
t2.start()
t1.join()	# 等待t1线程执行完毕,再继续执行剩余的代码
print(t1.getName())
print(t2.getName())

# Result:	
I am Two
I am One
one
two

def run(name, s): # 线程要执行的函数
 time.sleep(s) # 停两秒
 print('I am %s' % name)

# 实例化线程类, 并传入函数及其参数
t1 = threading.Thread(target=run, name='one', args=('One', 5))
t2 = threading.Thread(target=run, name='two', args=('Two', 2))
# 给t1设置守护模式, 使其随着主线程的结束而结束
t1.setDaemon(True)
# 开始执行, 这两个线程会同步执行
t1.start()
t2.start()	# 主线程会等待未设置守护模式的线程t2执行完成

# Result:
I am Two	# 运行后2s

a = 0
def incr(n):
 global a
 for i in range(n):
 a += 1
# 这两个方法同时声明了变量a,并对其进行修改
def decr(n):
 global a
 for i in range(n):
 a -= 1

t_incr = threading.Thread(target=incr, args=(1000000,))
t_decr = threading.Thread(target=decr, args=(1000000,))
t_incr.start()
t_decr.start()
t_incr.join()
t_decr.join()
print(a)
# 期望结果应该是0, 但是因为这里没有设置互斥锁, 所以两个方法是同时对同一个变量进行修改, 得到的的结果值是随机的

a = 0
lock = threading.Lock()	# 实例化互斥锁对象, 方便之后的调用

def incr(n):
 global a
 for i in range(n):
 lock.acquire()	# 上锁的方法
 a += 1
 lock.release()	# 解锁的方法
# 要注意的是上锁的位置是, 出现修改操作的代码
def decr(n):
 global a
 for i in range(n):
 with lock:	# 也可以直接使用with, 自动解锁
  a -= 1

t_incr = threading.Thread(target=incr, args=(1000000,))
t_decr = threading.Thread(target=decr, args=(1000000,))
t_incr.start()
t_decr.start()
t_incr.join()
t_decr.join()
print(a)
# Result: 0

import queue
q = queue.Queue(4)	# 实例化队列对象, 并设置最大数据量

q.put('a')
q.put('b')
print(q.get()) # : a
print(q.get()) # : b
q.task_done() # get后必须要加task_done,确认get操作是否完成

q.put(1)  # 当前队列已满,再次put就会阻塞
print(q.full()) # 由于已经阻塞, 所以这段不会被执行
# put会在队列慢了点时候，在插入值会发生阻塞
# get会在队列里没有值的时候，会发生阻塞

print(q.empty()) # 判断队列是否为空: True
q.put('test')
print(q.empty()) # : False

print(q.qsize()) # 当前队列里有多少人: 1

q.put(1)
q.put(1)
q.put(1)
print(q.full()) # : True

print('testetsetset')
q.join() # join会在队列非空时发生阻塞
print('done') # 由于已经阻塞, 所以这段不会被执行

import queue
import threading
import time


class ThreadPool: # 自定义线程池

 def __init__(self, n): # 主线程做

 self.queue_obj = queue.Queue()
 for i in range(n):
  threading.Thread(target=self.worker, daemon=True).start() # 给子线程worker设置为守护模式

 def worker(self): # 子线程做，由于Debug调试的只是主线程的代码，所以在调试时看不到子线程执行的代码
 """线程对象，写while True 是为了能够一直执行任务。"""
 while True: # 让线程执行完一个任务之后不会死掉，主线程结束时，守护模式会让worker里的死循环停止
  func = self.queue_obj.get() # get已经入队的任务, 这里会接收到主线程分配的func
  # 由于设置了守护模式，当队列为空时，不会一直阻塞在get这里
  # 有了守护模式，worker会在主线程执行完毕后死掉
  func() # 将队列里的任务拿出来调用
  """
  这里func与task_done的顺序非常重要，如果func放在task_done后面的话会出现只执行两次就结束。
  """
  self.queue_obj.task_done() # task_done 会刷新计数器
  # 线程池里有一个类似计数器的机制，用来记录put的次数（+1），每一次task_done都会回拨一次记录的次数（-1）
  # 当回拨完计数器为0之后，就会执行join

 def apply_async(self, func): # 主线程做
 """向队列中传入需要执行的函数对象"""
 self.queue_obj.put(func) # 将接收到的func入队

 def join(self): # 主线程做
 """等待队列中的内容被取完"""
 self.queue_obj.join() # 队列里不为空就阻塞，为空就不阻塞

def task1(): # 子线程做
 time.sleep(2)
 print('task1 over')

def task2(): # 子线程做
 time.sleep(3)
 print('task2 over')

P = ThreadPool(2) # 如果在start开启线程之后没有传入任务对象，worker里的get会直接阻塞
P.apply_async(task1)
P.apply_async(task2)

print('start')
P.join()
print('done')

# Result: 
start
task1 over
task2 over
done

from multiprocessing.pool import ThreadPool
import time

pool = ThreadPool(2) # 直接使用内置线程池, 设置最大线程数

def task1():
 time.sleep(2)
 print('task1 over')

def task2(*args, **kwargs):
 time.sleep(3)
 print('task2 over', args, kwargs)

pool.apply_async(task1)
pool.apply_async(task2, args=(1, 2), kwds={'a': 1, 'b': 2})
print('Task Submitted')
pool.close() # 要点: close必须要在join之前, 不允许再提交任务了
pool.join()
print('Mission Complete')

# Result:
Task Submitted
task1 over
task2 over (1, 2) {'a': 1, 'b': 2}
Mission Complete