进程线程 六 线程

进程

• CPU时间片：CPU处理的时间长度
• 进程是CPU分配资源的最小单位
  • 光有进程没有办法高效里用CPU资源
  • 进程会做IO等待，
• 内存独立：
  • 切换了，彼此多个进程不会影响
  • A,B,C, 数据不会乱
  • 一个进程挂掉，其他进程不会有事情

线程：CPU执行的最小单位

• 轻量级的进程：线程是内存共享的
  • CPU寄存器，计算器
  • 切换简单，CPU在切换执行任务的时候，损耗的时间少
  • 多线程如果处理数据，是并发，那么避免不了数据混乱，加锁，同步
• IO等待时可以切换
• 没有办法实现真正并发
• Python - CPython - .h Gudio
  • GIL锁，维持全局的线程同步执行
    • Golbal Lock
  • IO等待时切换
• Cpython中的多线程执行就是同步的：按照顺序，一个个来
• 进程：PID Process
• 线程也有：TID Thread
  • 只在当前的内存空间下有用
• 线程如果父进程退出，那么全部子线程，都会退出
  • 主线程死亡，子线程死亡
  • 主线程一般不要做大事，不要业务处理，
• 数据通信：
  • 本身内存共享，list,dict,str,int，这些数据都可以直接共享
• GIL：
  • 大锁，全局锁，直接锁掉线程，
• from threading import Thread
  • Process(target,args,)
  • t = Thread(target,args,name,kwargs)
    • t.start() 真正开启线程
    • t.join() 回收线程资源
• 只有纯计算没有IO的时候，多线程等同于单进程
  • 甚至是多线程效率低于单进程
• 多进程：多核心电脑
  • 计算密集
  • 多进程最快–>单进程–>多线程
• 多线程：
  • IO密集
    • QQ聊天

实例 单进程耗时

import time
def work_a(a): #GIL锁
	for var in range(1000000):
		a[0] += 1
	#a = [5]
def work_b(a):
	for var in range(1000000):
		a[0] += 1
		
def work_c(a):
	for var in range(1000000):
		a[0] += 1

a = [1]
start = time.time()
work_a(a)
print('------')
work_b(a)
print('------')
work_c(a)
print('------')
end = time.time()
print('程序耗时:%.2f' % (end - start))

实例

from multiprocessing import Process
from threading import Thread
import time

def work_a(a):
	for var in range(2500000):
		a[0] += 1
	print('a线程结束')


def work_b(a):
	for var in range(2500000):
		a[0] += 1
	print('b线程结束')

def work_c(a):
	for var in range(2500000):
		a[0] += 1
	print('c线程结束')


def work_d(a):
	for var in range(2500000):
		a[0] += 1
	print('d线程结束')


def main():
	a = [1]
	ta = Thread(target=work_a,args=(a,))
	tb = Thread(target=work_b,args=(a,))
	tc = Thread(target=work_c,args=(a,))
	td = Thread(target=work_d,args=(a,))

	pa = Process(target=work_a,args=(a,))
	pb = Process(target=work_b,args=(a,))
	pc = Process(target=work_c,args=(a,))
	pd = Process(target=work_d,args=(a,))

	start = time.time()
	ta.start()
	tb.start()
	tc.start()
	td.start()
	td.join()
	tc.join()
	tb.join()
	ta.join()
	end = time.time()
	print('多线程程序耗时:%.2fs' % (end - start))

	start = time.time()
	work_a(a)
	work_b(a)
	work_c(a) #0.76
	work_d(a)
	end = time.time()
	print('单进程程序耗时:%.2fs' % (end - start))

	start = time.time()
	pa.start()
	pb.start()
	pc.start()
	pd.start()
	pd.join()
	pc.join()
	pb.join()
	pa.join()
	end = time.time()
	print('多进程程序耗时:%.2fs' % (end - start))

if __name__ == '__main__':
	main()

线程的创建–多线程运行耗时

from threading import Thread
import time

#进程处理并发: 时间要少于单进程
#线程处理：等于，大于单进程
#同步: 0 - 8000 
#异步: 0 2000 1

def work_a(a): #GIL锁
	for var in range(1000000):
		a[0] += 1
	#a = [5]
	print('a线程结束')
def work_b(a):
	for var in range(1000000):
		a[0] += 1
	print('b线程结束')
def work_c(a):
	for var in range(1000000):
		a[0] += 1
	print('c线程结束')

def main():
	
	a = [1]
	start = time.time()

	ta = Thread(target=work_a,args=(a,))
	tb = Thread(target=work_b,args=(a,))
	tc = Thread(target=work_c,args=(a,))
	ta.start()
	tb.start()
	tc.start()

	ta.join()
	tb.join()
	tc.join()

	end = time.time()
	print('程序耗时:%.2f' % (end - start))

	#0.9 1.83
if __name__ == '__main__':
	main()

线程内存共享

from threading import Thread
import time

#GUI编程 QQ
def work(a):
	a[0] = 'a'

def main():
	a = [1]

	t = Thread(target=work,args=(a,))
	t.start()
	t.join()

	print(a) #最后结果

if __name__ == '__main__':
	main()