python多线程和多进程curr_线程，进程，GIL，join，Daemon，threading.current_thread()，threading.active_count()...

线程，进程，GIL，join，Daemon，threading.current_thread()，threading.active_count()

1.线程：线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执

行不同的任务。

一个线程就是一个指令集和

例：

#author: wylkjj

#date:2019/4/21

import time

import threading #创建线程所需要调用的模块

begin=time.time()

def foo(n):

print('foo%s'%n)

time.sleep(1)#sleep状态不占cpu，也就是cpu不工作

print('end foo')

def bar(n):

print('bar%s'%n)

time.sleep(2)

print('end bar')

# foo()

# bar()

t1=threading.Thread(target=foo,args=(1,))

t2=threading.Thread(target=bar,args=(2,))

#注：t1，t2，还有原进程同时进行，不分先后(抢占cpu资源)

print('......in the main......')

t1.start()#执行子进程

t2.start()#执行子进程

end=time.time()

print(end-begin)#程序运行时间：0.0009768009185791016

t1.join()#卡住进程

t2.join()#卡住进程

end=time.time()

print(end-begin)#卡住进程后的程序运行时间：2.001460075378418

#注：并行：并行是同时进行，真正意义上的两件事情同时干

# 多核，当一核运行一个程序，两个程序两核同时运行就是并行

# 并发：并发并不是同时进行

注：

#多线程：IO密集型任务或函数(有阻塞情况的，例如：time.sleep())

#计算密集型任务函数不适合多线程

import time

import threading

begin=time.time()

def add(n):

sum=0

for i in range(n):

sum+=1

print(sum)

#串行

# add(10000000)

# add(20000000)

# end=time.time()

# print(end-begin)#运行时间：1.6457252502441406

#并发：此并发无阻塞所以要保存切换时的状态，切换会消耗大量时间(一核cpu下并发，多核就可以并行)

t1=threading.Thread(target=add,args=(10000000,))

t2=threading.Thread(target=add,args=(20000000,))

t1.start()

t2.start()

t1.join()

t2.join()

#join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一

#直等待其他的子线程执行结束之后，主线程在终止，否则主线程会杀死子线程

#主线程结束后子线程无论是否执行完毕都将结束，因此join的作用就显现出来了

end=time.time()

print(end-begin)#运行时间：1.6939148902893066

2.进程：是一堆资源的整合，一个程序的执行实例(注：进程不可以资源共享，但线程可以资源共享)

注：线程和进程一样块(线程在执行时，等于进程，同一个体系)注：进程开销大

3.GIL(global interpreter lock)解释器上的一个bug，只有cpython解释器有这个问题，因为cpython里面加了一把锁GIL

GIL：在同一时刻只能有一个线程进入解释器(历史问题)

4.python里面因为GIL锁所以一个进程无法多线程，所以只能用多进程去实现多线程(可行但不完美)

结论：在python里：

if任务是IO密集型的 可以用多线程

面对计算密集型，改cpython或用其它解决办法

(1)进程是相互独立互不影响的，但线程中主线程会影响子线程

(2)无论什么情况进程中同一时刻只能有一个线程运行，如果想

运用多核就要创建多进程

5.join():阻塞作用

join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，

一直等待其他的子线程执行结束之后，主线程在终止

join有一个timeout参数：

(1).当设置守护线程时，含义是主线程对于子线程等待timeout的时间将会杀死该子线程，最后退出程序。所以说，如果有10个子

线程，全部的等待时间就是每个timeout的累加和。简单的来说，就是给每个子线程一个timeout的时间，让他去执行，时间一到，

不管任务有没有完成，直接杀死。

(2).没有设置守护线程时，主线程将会等待timeout的累加和这样的一段时间，时间一到，主线程结束，但是并没有杀死子线程，

子线程依然可以继续执行，直到子线程全部结束，程序退出。

6.Daemon：(守护线程，守护进程)

在脚本运行过程中有一个主线程，若在主线程中创建了子线程，当主线程结束时根据子线程daemon属性值的不同可能会发生下面的两种情

况之一。

(1)如果某个子线程的daemon属性为False，主线程结束时会检测该子线程是否结束，如果该子线程还在运行，则主线程会等待它完成后

再退出；

(2)如果某个子线程的daemon属性为True，主线程运行结束时不对这个子线程进行检查而直接退出，同时所有daemon值为True的子线程

将随主线程一起结束，而不论是否运行完成。

属性daemon的值默认为False，如果需要修改，必须在调用start()方法启动线程之前进行设置。另外要注意的是，上面的描述并不适用于

IDLE环境中的交互模式或脚本运行模式，因为在该环境中的主线程只有在退出Python IDLE时才终止。

7.threading.current_thread():print(threading.current_thread())查看线程情况，分级出子线程和主线程，当前执行的线程是哪个

8.threading.active_count()：print(threading.active_count())：查看进程中还有几个线程在运行(未jion的)

(7、8)实例：

import time

import threading #创建线程所需要调用的模块

begin=time.time()

def foo(n):

print(threading.current_thread())

print('foo%s'%n)

time.sleep(1)#sleep状态不占cpu，也就是cpu不工作

print('end foo')

def bar(n):

print(threading.current_thread())

print('bar%s'%n)

time.sleep(2)

print('end bar')

# foo()

# bar()

t1=threading.Thread(target=foo,args=(1,))

t2=threading.Thread(target=bar,args=(2,))

#注：t1，t2，还有原进程同时进行，不分先后(抢占cpu资源)

print('......in the main......')

t1.start()#执行子进程

t2.start()#执行子进程

end=time.time()

print(end-begin)#程序运行时间：0.0009768009185791016

# t1.join()#卡住进程

# t2.join()#卡住进程

end=time.time()

print(threading.current_thread())

print(threading.active_count())#进行中的进程(加jion给两个子线程就只有1个主线程在运行，不加join给两个子线程就有3个运行数)

print(end-begin)#卡住进程后的程序运行时间：2.001460075378418