import threading
import time


def f1(*args):
	time.sleep(5)
	print(args)

# 单进程，单线程
t = threading.Thread(target=f1, args=(123,))
t.setDaemon(True)
# 设置为True，表示主线程不等子线程执行完就结束整个程序
# 设置为False，表示主进程等子线程结束后才会结束整个程序
t.start()   # 一个线程

t.join()
# 不加参数，默认表示主线程一直等待，等到子线程执行完毕,才会往下走。
# 加参数，参数表示主线程在此最多等待n秒

print("end")

import queue
q = queue.Queue(2)  # 里面参数表示最多可以放的元素的个数（默认为没有个数限制），如果超过这个个数，默认会阻塞。
q.put(1)   # 放数据
q.put(2)
print(q.qsize())  # 队列中元素的个数
q.put(6, block=False)  # 放数据时默认会阻塞，即block为True；否则，block为False时，如果放不进去，会直接报错！
q.put(3, block=False, timeout=2)  # 后面还可以接超时时间，如果2秒后仍然放不进去，则直接报错！

print(q.qsize())  # 队列中元素的个数
print(q.get())  # 取数据

import queue
q = queue.Queue(2)
q.put(1)
q.put(2)
q.get()
q.task_done()
q.get()
q.task_done()
q.join()

import queque	
q = queue.LifoQueue()  # 后进先出队列（last in first out）

q.put(123)
q.put(456)
r = q.get()
print(r)

#执行结果：
#456

import queque
q = queue.PriorityQueue()  # 优先级队列

q.put((0, ‘tom‘))  # 两个参数，前面一个是优先级，后面一个是放进去的数据，优先级越高，先出
q.put((5, ‘lily‘))
q.put((2, ‘yn‘))
r = q.get()
print(r)

#执行结果：
#tom

import queue

q = queue.deque()  # 双向队列（两头进两头出）

q.append("hello")
q.append("world")
q.appendleft("tom")
r = q.pop()
r1 = q.popleft()
print(r)
print(r1)

#执行结果：

#world
#tom

import threading
import time
NUM = 10 


def f1(l):
	global NUM
	# 上锁
	l.acquire()
	NUM -= 1
	time.sleep(2)
	print(NUM)
	# 开锁
	l.release()

# lock = threading.Lock()
lock = threading.RLock()

for i in range(10):
	t = threading.Thread(target=f1, args=(lock,))
	t.start()

import threading
import time
NUM = 10


def f1(l):
	global NUM
	# 上锁
	l.acquire()   # 这时每次只放行2个
	NUM -= 1
	time.sleep(2)
	print(NUM)
	# 开锁
	l.release()

# lock = threading.Lock()
# lock = threading.RLock()
lock = threading.BoundedSemaphore(2)  # 允许同时最多有2个同时运行
for i in range(10):
	t = threading.Thread(target=f1, args=(lock,))
	t.start()

import threading


def f1(i, e):
	print(i)
	e.wait()   # 检测是什么灯，如果是红灯，停；如果是绿灯，行。
	print(i + 100)

event = threading.Event()
for i in range(10):
	t = threading.Thread(target=f1, args=(i, event))
	t.start()
# ------------------
event.clear()   # 设置为红灯，全部暂停
inp = input(‘>>>‘)
if inp == ‘1‘:
	event.set()  # 设置为绿灯，设置为绿灯，全部放行。

from threading import Timer

def f1():
	print("hello, world !")
t = Timer(10, f1)
t.start()

import queue
import threading
import time


class ThreadPoll:
	def __init__(self, maxsize=5):
		self.maxsize = maxsize
		self._q = queue.Queue(maxsize)
		for i in range(maxsize):
			self._q.put(threading.Thread)
			# [threading.Thread, threading.Thread, threading.Thread, threading.Thread]

	def get_thread(self):
		return self._q.get()

	def add_thread(self):
		self._q.put(threading.Thread)

# 最多有5的允许5个线程
poll = ThreadPoll(5)


def task(args, p):
	print(args)
	time.sleep(1)
	p.add_thread()
	# 如果没有最后这个步的话，到第六个get_thread()会因为获取不到线程而阻塞住
	# 所以在取走一个线程之后再添加一个线程。


for i in range(100):
	t = poll.get_thread()  # 此时的t为threading.Tread类
	obj = t(target=task, args=(i, poll,))  # 创建一个threading.Tread对象
	obj.start()

#!/usr/bin/python
# _*_ coding:utf-8 _*_
import queue
import threading
import contextlib
import time
# 队列里面直接放任务，[(函数名,参数1)，(函数名,参数2)，(函数名,参数3)]


StopEvent = object()


class ThreadPool(object):
	def __init__(self, max_num, max_task_num=None):
		if max_task_num:
			self.q = queue.Queue(max_task_num)
		else:
			self.q = queue.Queue()
		self.max_num = max_num
		self.cancel = False
		self.terminal = False
		self.generate_list = []  # 当前已经创建了多少线程
		self.free_list = []  # 当前还空闲多少线程

	def run(self, func, args, callback=None):
		"""
		线程池执行一个任务
		:param func: 任务函数
		:param args: 任务函数所需参数
		:param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；2、任务函数返回值（默认为None，即：不执行回调函数）
		:return: 如果线程池已经终止，则返回True否则None
		"""
		if self.cancel:
			return
		if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
			# 当没有空闲的线程数，而且已经能够创建的线程数小于最大的线程数时，则创建线程
			self.generate_thread()
		w = (func, args, callback,)
		self.q.put(w)  # 如果不满足上述判断的话，只把任务放在队列中而不会去创建线程

	def generate_thread(self):
		"""
		创建一个线程
		"""
		t = threading.Thread(target=self.call)
		t.start()

	def call(self):
		"""
		循环去获取任务函数并执行任务函数
		"""
		current_thread = threading.currentThread
		self.generate_list.append(current_thread)

		event = self.q.get()
		while event != StopEvent:

			func, arguments, callback = event
			try:
				result = func(*arguments)
				success = True
			except Exception as e:
				success = False
				result = None

			if callback is not None:
				try:
					callback(success, result)
				except Exception as e:
					pass

			with self.worker_state(self.free_list, current_thread):
				if self.terminal:
					event = StopEvent
				else:
					event = self.q.get()
		else:

			self.generate_list.remove(current_thread)

	def close(self):
		"""
		执行完所有的任务后，所有线程停止
		"""
		self.cancel = True
		full_size = len(self.generate_list)
		while full_size:
			self.q.put(StopEvent)
			full_size -= 1

	def terminate(self):
		"""
		无论是否还有任务，终止线程
		"""
		self.terminal = True

		while self.generate_list:
			self.q.put(StopEvent)

		self.q.empty()

	@contextlib.contextmanager
	def worker_state(self, state_list, worker_thread):
		"""
		用于记录线程中正在等待的线程数
		"""
		state_list.append(worker_thread)
		try:
			yield
		finally:
			state_list.remove(worker_thread)

# ----------------执行--------------------------
pool = ThreadPool(5)


def callback(status, result):  # 定义的任务
	# status, execute action status
	# result, execute action return value
	pass


def action(i):
	print(i)


for i in range(300):
	ret = pool.run(action, (i,), callback)

# time.sleep(1)
# print(len(pool.generate_list), len(pool.free_list))
# print(len(pool.generate_list), len(pool.free_list))

from multiprocessing import Process


def f1(i):
	print("hello,{}".format(i))

if __name__ == ‘__main__‘:
	# 注意在windows必须加这一段，否则会报错！但是，在linux，mac没有上述一行代码依然可以执行！
	# 所以，在windows下慎用多进程！
	for m in range(10):
		p = Process(target=f1, args=("tom",))
		# p.daemon = True
		p.start()
		# p.join()

from multiprocessing import Process
import threading
import time


def f1(i, args):
	args.append(i)
	print("hello,{}".format(i), args)

if __name__ == ‘__main__‘:
	# 注意在windows必须加这一段，否则会报错！但是，在linux，mac没有上述一行代码依然可以执行！
	li = []
	for m in range(5):
		p = Process(target=f1, args=(m, li))
		# p = threading.Thread(target=f1, args=(m, li))
		# p.daemon = True
		p.start()
		# p.join()

from multiprocessing import Process
from multiprocessing import queues
import multiprocessing


def f1(i, args):
	args.put(i)
	print(args.qsize())

if __name__ == ‘__main__‘:
	li = queues.Queue(20, ctx=multiprocessing)
	for m in range(5):
		p = Process(target=f1, args=(m, li))
		p.start()

from multiprocessing import Process
from multiprocessing import Array


def f1(i, args):
	args[i] = i + 100
	for n in args:
		print(n)
	print("---------")


if __name__ == ‘__main__‘:
	li = Array(‘i‘, 6)   # 创建数组，规定好是字符型，数量为6个，这里的数组是C语言的格式
	for m in range(5):
		p = Process(target=f1, args=(m, li))
		p.start()

from multiprocessing import Process
from multiprocessing import Manager


def f1(i, args):
	args[i] = i + 100
	print(args.values())

if __name__ == ‘__main__‘:
	obj = Manager()
	li = obj.dict()
	for m in range(5):
		p = Process(target=f1, args=(m, li))
		p.start()
		p.join()    # 重要

from multiprocessing import Process, Array
from multiprocessing import RLock, Lock, Event, Condition, Semaphore
import time


def f1(i, lis, lc):
	lc.acquire()
	lis[0] = lis[0] - 1
	time.sleep(1)
	print(‘hello,‘,lis[0])
	lc.release()
if __name__ == ‘__main__‘:
	li = Array(‘i‘, 1)
	li[0] = 10
	lock = RLock()
	for m in range(5):
		p = Process(target=f1, args=(m, li, lock))
		p.start()
		p.join()

from multiprocessing import Pool
import time

def f1(args):
	print(args)

if __name__ == ‘__main__‘:
	pool = Pool(5)
	for i in range(30):
		# pool.apply(func=f1, args=(i,))  # 这是串行来执行的
		pool.apply_async(func=f1, args=(i, ))  # 这是异步执行的
	pool.close()  # 所有的任务执行完毕，才关闭
	# time.sleep(1)
	# pool.terminate()  # 立即终止当前任务！
	pool.join() # 等待所有的任务执行完毕才会终止

from greenlet import greenlet


def test1():
	print(12)
	gr2.switch()
	print(34)
	gr2.switch()


def test2():
	print(56)
	gr1.switch()
	print(78)


gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()

import gevent


def f1():
	print("welcome to f1")
	gevent.sleep(0)
	print("welcome to f1 agin !")


def f2():
	print("welcome to f2")
	gevent.sleep(0)
	print("welcome to f2 agin !")

gevent.joinall([gevent.spawn(f1), gevent.spawn(f2)])

from gevent import monkey
import gevent
import requests
monkey.patch_all()  # 把原来的socket功能修改了，发完请求的会告诉你发送完了，用上它，才能用协程


def f1(url):
	print("GET %s" % url)
	resp = requests.get(url)
	data = http://www.mamicode.com/resp.text"%d bytes received from %s." % (len(data), url))

gevent.joinall([
	gevent.spawn(f1, "https://www.baidu.com/"),
	gevent.spawn(f1, "https://www.python.org/"),
	gevent.spawn(f1, "https://www.sina.com/"),
])