进程和线程

进程和线程

• 进程：正在执行的程序。
  在实现了进程的操作系统中。
• 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一个程序执行实例就是一个进程。
• 现代操作系统提出进程的概念，每一个进程都认为自己是计算机硬件资源，进程就是独立的王国，进程间不可以随便的共享资源。
• 线程就是省份，同一个进程内的线程可以共享进程的资源，每一个线程拥有自己独立的堆栈。

线程的状态

状态	含义
就绪	线程能够运行，但是在等待被调度，可能线程刚刚创建启动，或刚刚从阻塞中恢复，或者被其他线程抢占
运行	线程正在运行
阻塞	线程等待外部事件发生而无法运行
终止	线程完成，或退出，或被取消

Python中的进程和线程

进程会启动一个解释器进程，线程共享一个解释器进程。

Python的线程开发

Python的线程开发使用标准库threading
进程靠线程执行代码，至少有一个主线程，其他线程是工作线程。
主线程是第一个启动的线程。

Thread类

#签名
def __init__(self,group=None,target=None,name=None,args=().kwargs=None,*,daemon=None)

参数名	含义
target	线程调用的对象，就是目标函数
name	为线程起个名字
args	为目标函数传递实参，元组
kwargs	为目标函数关键字传参，字典

线程的启动

import threading
def worker():
   print('work')
t=threading.Thread(target=worker,name='work')
t.start()

通过threading.Thread创建一个线程对象，target是目标函数，可以使用name为线程指定名称。
但是线程没有启动，需要调用start方法。
线程之所以执行函数，因为线程中就是要执行的代码。

线程退出

Python中没有提供线程退出的方法，线程在下面情况时退出

• 线程函数内语句执行完毕
• 线程函数中抛出未处理的异常

import threading
def worker():
    raise Exception('1')
    while True:
        print('work')
t=threading.Thread(target=worker,name='work')
t.start()

Python的线程没有优先级，没有线程组的概念，也不能比销毁、停止、挂起，也没有恢复、中断

线程的传参

import threading
import  time
def add(x,y):
    print(threading.current_thread().ident)
    print(threading.current_thread().name)
    print(x+y)
    return x+y
t=threading.Thread(target=add,name='add',args=(1,2))
t.start()

threading的属性和方法

名称	含义
current_thread()	返回当前线程对象
main_thread()	返回主线程对象
active_count()	当前处于alive状态的线程个数
enumerate()	返回所有活着的线程的列表，不包括已经终止的线程和未开始的线程
get_ident()	返回当前线程的ID，非0整数

import threading
import  time
def show():
    print(threading.current_thread())
    print(threading.main_thread())  
    print(threading.active_count())   
    print(threading.enumerate())   
    print(threading.get_ident())  
def work():
    # show()
    for i in range(5):
        time.sleep(1)
        print('work')
t=threading.Thread(target=work,name='work')
t.start()
show()

##### Thread实例的属性和方法

名称	含义
name	只是一个名字，一个表示，名字可以重名，getName(),setName()获取、设置这个名词
ident	线程ID，是非0整数。线程启动才有ID，否则为None，线程退出，ID依旧可以访问
is_alive()	返回线程是否活着

import threading
import time
def work():
    for i in range(5):
        time.sleep(2)
        print('working')
    print('finish')
t=threading.Thread(target=work,name='work')
print(t.name,t.ident)
time.sleep(1)
t.start()
print('++++++++++')
while True:
    time.sleep(1)
    print('alive',t.is_alive())
    print('ID',t.ident)
    print('name',t.name)
    break

start和run

名称	含义
start()	启动线程，每一个线程必须且只能执行该方法一次
run()	运行线程函数

• start

import threading
import time
def work():
    for i in range(5):
        time.sleep(1)
        print('work')
    print('finish')
class Mythread(threading.Thread):
    def start(self):
        print('start____________')
        super().start()
    def run(self):
        print('run______________')
        super().run()
t=Mythread(target=work,name='work')
t.start()

• run

import threading
import time
def work():
    for i in range(5):
        time.sleep(1)
        print('work')
    print('finish')
class Mythread(threading.Thread):
    def start(self):
        print('start____________')
        super().start()
    def run(self):
        print('run______________')
        super().run()
t=Mythread(target=work,name='work')
# t.start()
t.run()

start()方法会调用run()方法，而run()方法可以运行函数。

• start和run的区别

import threading
import time
def work():
    print(threading.enumerate())
    for i in range(5):
        time.sleep(1)
        print('work')
    print('finish')
class Mythread(threading.Thread):
    def start(self):
        print('start____________')
        super().start()
    def run(self):
        print('run______________')
        super().run()
t=Mythread(target=work,name='work')
# t.start()
t.run()

import threading
import time
def work():
    print(threading.enumerate())
    for i in range(5):
        time.sleep(1)
        print('work')
    print('finish')
class Mythread(threading.Thread):
    def start(self):
        print('start____________')
        super().start()
    def run(self):
        print('run______________')
        super().run()
t=Mythread(target=work,name='work')
t.start()
# t.run()

使用start方法启动线程，启动了一个新的线程，但是使用run方法，并没有启动新的线程，就是在主线程中调用了一个普通的函数而已。

多线程

多个线程，一个进程如果有多个线程进行，就是多线程，实现一种并发。

import threading
import time
def work():
    t=threading.current_thread()
    for i in range(5):
        time.sleep(1)
        print('work',t.name,t.ident)
    print('finish')
class Mythread(threading.Thread):
    def start(self):
        print('start____________')
        super().start()
    def run(self):
        print('run______________')
        super().run()
t1=Mythread(target=work,name='work1')
t1.start()
t2=Mythread(target=work,name='work2')
t2.start()

可以看到work1和work2交替执行。

import threading
import time
def work():
    t=threading.current_thread()
    for i in range(5):
        time.sleep(1)
        print('work',t.name,t.ident)
    print('finish')
class Mythread(threading.Thread):
    def start(self):
        print('start____________')
        super().start()
    def run(self):
        print('run______________')
        super().run()
t1=Mythread(target=work,name='work1')
# t1.start()
t1.run()
t2=Mythread(target=work,name='work2')
# t2.start()
t2.run()

没有新的线程，就是函数普通调用，执行完t1.run()，执行t2.run(),这里不是多线程。
当使用start方法启动线程后，进程内有多个活动的线程并行的工作，就是多线程。
一个进程中至少有一个线程，作为程序的入口，这个线程就是主线程。
一个进程至少一个主线程
其他线程称为工作线程。

线程安全

import threading
import time
def work():
    t=threading.current_thread()
    for i in range(5):
        time.sleep(1)
        print('work',t.name,t.ident)
    print('finish')
class Mythread(threading.Thread):
    def start(self):
        print('start____________')
        super().start()
    def run(self):
        print('run______________')
        super().run()
t1=Mythread(target=work,name='work1')
t1.start()
t2=Mythread(target=work,name='work2')
t2.start()

代码中有空行和被打印在一起的。

• 线程安全：线程执行一段代码，不会产生不确定的结果，那这段代码就是线程安全的

为了出现线程不安全：使用logging
标准库里面的logging模块，日志处理模块，线程安全的，生成环境代码都使用logging

import threading
import time
import logging
def work():
    t=threading.current_thread()
    for i in range(5):
        time.sleep(1)
        logging.warning('work')
        logging.warning(t.name)
        logging.warning(t.ident)
        logging.warning('~~~~~~~~~~~~~~~~~~~~~~~~~')
    print('finish')
class Mythread(threading.Thread):
    def start(self):
        print('start____________')
        super().start()
    def run(self):
        print('run______________')
        super().run()
t1=Mythread(target=work,name='work1')
t1.start()
# t1.run()
t2=Mythread(target=work,name='work2')
t2.start()
# t2.run()

daemon线程和non-daemon线程

Python中，构建线程的时候，可以设置daemon属性，这个属性必须在start方法前设置好

#源码Thread的__init__方法中
if daemon is not None:
       self._daemonic=daemon #用户设定的bool值
else:
       self._daemonic=current_thread()

线程daemon属性，如果设定就是用户的设置，否则就取当前线程的daemon值。
主线程是non-daemon线程，即daemon=False

import time
import threading
def foo():
    time.sleep(2)
    for i in range(10):
        print(i)
t=threading.Thread(target=foo,daemon=False)
t.start()
print('final')

from threading import Thread
class M(Thread):
    def __init__(self):
        Thread.__init__(self,name='M',daemon=False)
import time
import threading
def foo():
    time.sleep(2)
    for i in range(10):
        print(i)
t=threading.Thread(target=foo,daemon=True)
t.start()
print('final')

daemon为False，主线程会等待线程t，直到线程t结束。
daemon为True时，主线程并不会等待线程t。

名称	含义
daemon属性	表示线程是否是daemon线程，这个值必须在start()之前设置，否则引发RuntimeError异常
isDaemon()	是否是daemon线程
setDaemon	设置为daemon线程，必须在start方法之前设置

import time
import threading
def work(name,ti):
    time.sleep(ti)
    print(threading.current_thread().daemon)
    print(name)
t1=threading.Thread(target=work,args=('t1',5),daemon=False)
t1.start()
t2=threading.Thread(target=work,args=('t2',10),daemon=False)
t2.start()
print('final____________')

上例子说明如果除了主线程之外还有non-daemon线程的时候，主线程退出时，也不会杀掉所有daemon线程，直到所有的non-daemon线程全部结束，如果还有daemon线程，主线程需要退出(主线程退出也可以理解为最后一个non-daemon线程也要退出了)，会结束所有daemon线程，程序退出。

• 总结
  • 线程具有一个daemon属性，可以手动设置为True或False，也可以不设置，则取当前线程的daemon来设置它。
  • 主线程是non-daemon线程，即daemon=False
  • 从主线程创建的所有线程都不设置daemon属性，则默认都是daemon=False，也就是non-daemon线程。
  • Python程序在没有或者的non-daemon线程运行时，程序退出，也就是除主线程外剩下的只能都是daemon线程，主程序才能退出，否则主线程只能等待。

join方法

import time
import threading
def work(name,ti):
    time.sleep(ti)
    print(threading.current_thread().daemon)
    print(name)
t1=threading.Thread(target=work,args=('t1',10),daemon=True)
t1.start()
t1.join()
print('final____________')

使用了join方法后，daemon线程执行完了，主线程才能退出

import time
import threading
def work(name,ti):
    time.sleep(ti)
    print(threading.current_thread().daemon)
    print(name)
t1=threading.Thread(target=work,args=('t1',10),daemon=True)
t1.start()
t1.join(2)
print('final____________')
t1.join(2)
print('final____________')

join(timeout=None),是线程的标准方法之一。
一个线程中调用另一个线程的join方法，调用者将被阻塞，直到被调用线程终止，一个线程可以被join多次。
timeout参数指定调用者等待多久，没有设置超时，就一直等到被调用线程结束。
调用谁的join方法，就是join谁，就要等谁。

daemon线程应用场景

简单来说就是，本来没有daemon thread，为了简化程序员的工作，让他们不用去记录和管理那些后台线程，创造了一个daemon thread的概念，这个概念唯一的作用就是，当你把一个线程设置为daemon，它可以随主线程的退出而退出。
主要应用场景：
1、后台任务
2、主线程任务才有用的线程。
3、随时可以被终结的线程。

• 如果主线程退出，想所有其它工作线程一起退出，就使用daemon=True来创建工作线程。
• 如果在non-daemon线程A中，对另一个daemon线程B使用了join方法，这个线程B设置成daemon就没有什么意义了，因为non-daemon线程A总是要等待B。
• 如果在non-daemon线程C中，对另一个daemon线程D使用了join方法，只能说明C要等待D，主线程退出，C和D不管是否结束，都要结束掉。

import time
import threading
def work1(name):
    while True :
        time.sleep(2)
        print(threading.current_thread().isDaemon())
def work2(name):
    current=threading.current_thread()
    print(name,current.isDaemon())
    t2=threading.Thread(target=work1,args=('t2',))
    t2.start()
t1=threading.Thread(target=work2,args=('t1',),daemon=True)
t1.start()
time.sleep(3)
print('over')

上例，主要主线程要退出，2个工作线程都结束。
可以使用Join，让线程结束不了。

import time
import threading
def work1(name):
    while True :
        time.sleep(2)
        print(threading.current_thread().isDaemon())
def work2(name):
    current=threading.current_thread()
    print(name,current.isDaemon())
    t2=threading.Thread(target=work1,args=('t2',))
    t2.start()
t1=threading.Thread(target=work2,args=('t1',),daemon=True)
t1.start()
t1.join()
time.sleep(4)
print('over')

threading.local类

import time
import threading
import logging
def foo():
    x=0
    for i in range(10):
        time.sleep(0.1)
        x+=1
    logging.warning('{}{}'.format(threading.current_thread(),x))
for i in range(10):
    threading.Thread(target=foo).start()

上例使用多线程，每个线程完成不同的计算任务，x是局部变量，可以看出每一个线程的x是独立的，互不干扰。

import time
import threading
import logging
class A:
    def __init__(self):
        self.x=0
#全局对象
globals_data=A()
def work():
    globals_data.x=0
    for i in range(10):
        time.sleep(0.1)
        globals_data.x+=1
    logging.warning("{}{}".format(threading.current_thread(),globals_data.x))
for i in range(10):
    threading.Thread(target=work).start()

上例使用了全局对象，但是线程之间互相干扰，导致了超出预期的结果。
Python提供了threading.local类，将实例化得到一个全局对象，但是不同线程使用这个对象存储的数据其他线程看不见。

import time
import threading
import logging
#全局对象
globals_data=threading.local()
def work():
    globals_data.x=0
    for i in range(10):
        time.sleep(0.1)
        globals_data.x+=1
    logging.warning("{}{}".format(threading.current_thread(),globals_data.x))
for i in range(10):
    threading.Thread(target=work).start()

import threading
x='abc'
global_data=threading.local()
global_data.x=100
print(global_data,type(global_data),global_data.x)
def woek():
    print(x)
    print(global_data)
    print(global_data.x)
    print('work')
woek()
print('~~~~~~~~~~~')
threading.Thread(target=woek).start()

从运行结果来看，另一个线程打印global_data.x出错了。

AttributeError: '_thread._local' object has no attribute 'x'

但是，global_data打印没有出错，说明看到global_data,但是global_data中的x看不到，这个x不能跨进程。
threading.local类构建了一个大字典，存放所有线程相关的字典定义如下：
｛id(Thread)->(ref(Thread),thread-locla dict)｝
每一个线程实例的id为key，元组为value。
value中有两部分，线程对象引用，每个线程自己的字典。