python 基础：线程 和 进程

• 进程：一个程序的执行实例， 地址空间，内存，数据栈，辅助数据(独立的)。在主线程中
• 线程： 同一进程中，信息共享和通信。访问差异会导致结果不一致。
  python 程序中由global interpreter lock(GIL),主循环中要求只能有一个控制线程运行。

线程

threading 实现线程

import time
import threading
# threading.Thread() 是线程

# 每个线程的内容, 等待n秒
def worker(n):
	print('函数执行开始于：{} '.format(time.ctime()))
	time.sleep(n)
	print('函数执行结束于：{}, 线程名：{}'.format(time.ctime(),threading.current_thread().name))

# 继承threading.Thread，重写run(): 线程执行接口
class MyThread(threading.Thread)：
	def __int__(self, func, args):
		threading.Thread.__init__(self)
		self.func = func
		self.args = args

	# start 启动
	def run(self):
		# 解包
		self.func(*self.args)

# 主函数，生成两个线程对象，入线程池threads,.start() 开始, .join() 守护线程，主函数等子线程全部执行后在结束。
def main():
	print('[主函数执行开始于：{}]'.format(time.ctime()))
	threads = []
	t1 = MyThread(worker, (4,))
	threads.append(t1)

	t2 = MyThread(worker, (2,))
	threads.append(t2)

	for t in threads:
		t.start()

	for t in threads:
		t.join()
	print('[主函数执行结束于：{}]'.format(time.ctime()))

if __name__ == '__mian__':
	main()

生产者，消费者实例

import threading
import queue
import time
import random

# 生成者， 产生随机数到 data_queue 队列中, data_queue.put()
def producer(data_queue):
	for i in range(5):
		time.sleep(0.5)
		item = random.randint(1, 100)
		data_queue.put(item)
		print("{} 在队列中放入数据项 {}".format(threading.current_thread().name, item))

# 消费者，从队列中取出一个数，data_queue.task_done()
def consumer(data_queue):
	while True:
		try:
			item = data_queue.get(timeout=3)
			print('{} 从队列中移除了'.format(threading.current_thread().name))
		except queue.Empty:
			break
		else:
			data_queue.task_done()
# 主函数，生成4个线程到线程池，2个生成者，2个消费者。
def main():
	q = queue.Queue()
	threads = []

	p = threading.Thread(target=producer, args=(q,))	
	p.start()

	for i in range(2):
		c = threading.Thread(target=consumer, args=(q,))
		threads.append(c)

	for t in threads:
		t.start()

	for t in threads:
		t.join()

	q.join()
	
main()

线程同步

同步原语(锁)

import time
import threading
import random

eggs = []
lock = threading.Lock()

def put_egg(n, lst):
	# lock.acquire()
	with lock:
		for i in range(1, n+1):
			time.sleep(random.randint(0,2))
			lst.append(i)
	# lock.release()

def main():
	threads = []
	for i in range(3):
		t = threading.Thread(target= put_egg, args=(5, eggs))
		threads.append(t)

	for t in threads:
		t.start()
	for t in threads:
		t.join()
	print(eggs)

main()

进程

进程，线程，线性执行速度对比。

import time
import concurrent.futures


numbers = list(range(1,7))

def count(n):
	for i in range(10000000):
		i += 1
	return i*n

def worker(x):
	result = count(x)
	print('数字：{}的计算结果为：{}'.format(x, result))

# 顺序执行
def sequential_excution():
	start_time = time.clock()

	for i in numbers:
		worker(i)
	print('顺序执行花费时间：{} 秒'.format(time.clock()-start_time))

# 线程执行
def thread_execution():
	start_time = time.clock()
	with concurrent.futures.ThreadPoolExecutor(max_workers=5) as excuter:
		for i in numbers:
			excuter.submit(worker, i)

	print('多线程执行花费时间: {}'.format(time.clock()-start_time))


# 多进程 进程池执行
def process_excution():
	start_time = time.clock()
	with concurrent.futures.ProcessPoolExecutor(max_workers=1) as excuter:
		for i in numbers:
			excuter.submit(worker, i)
	
	print('多进程执行花费时间: {}'.format(time.clock()-start_time))

if __name__ == '__main__':
	# sequential_excution()
	# thread_execution()
	process_excution()