一 基本概念

1 并行和并发

1 并行,parallel

同时做某些事,可以互不干扰的同一时刻做几件事
如高速公路上的车道,同一时刻,可以有多个互不干扰的车运行
在同一时刻,每条车道上可能同时有车辆在跑,是同时发生的概念

2 并发,concurrency

也是同时做某事,但强调的是同一时段做了几件事。
并行是可以解决并发问题的。

2 并发的解决

1 队列,缓冲区

队列:排队就是队列,先进先出,解决了资源使用的问题。
缓冲区:排程的队列,其实就是一个缓冲地带,就是缓冲区
优先队列:对比较重要的事进行及时的处理,此处就是优先队列

2 争抢

只开一个窗口,有可能没秩序,也就是谁挤进去就给谁打饭
挤到窗口的人占据窗口,直到达到饭菜离开,其他人继续争抢,会有一个人占据窗口,可以视为锁定窗口,窗口就不能为其他人提供服务了,这是一种锁机制,抢到资源就上锁,排他性锁,其他人只能等候

争抢也是一种高并发解决方案,但是,不好,因为有人可能长时间抢不到。

3 预处理

一种提前加载用户需要的数据的思路,如预热,预加载等,缓存中常用
缓存的思想就是将数据直接拿到,进行处理。

4 并行

可通过购买更多的服务器,或开多线程,进行实现并行处理,来解决并发问题,这些都是水平扩展,

5 提速

提高单个CPU性能,或者单个服务器安装更多的CPU,但此和多个服务器相比成本较高

6 消息中间件

通过中间的缓冲器来解决并发问题,如rabbitmq,activemq,rocketmq,kafka 等,CDN也算是一种

3 进程和线程概念

1 进程和线程

在实现了线程的操作系统中,线程是操作系统能够运算调度的最小单位,他被包含在进程中,是进程中的实际运作单位,一个程序的执行实例就是一个进程


进程(process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础

2 进程和线程的关系

程序是源代码编译后的文件,而这些文件存放在磁盘上,当程序被操作系统加载到内存中,就是进程,进程中存放着指令和数据(资源),它也是线程的容器。


Linux进程有父进程,子进程,windows中进程之间是平等关系


线程有时候被称为轻量级进程(LWP),是程序执行的最小单元,一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成

3 进程,线程的理解

现代操作系统提出进程的概念,每一个进程都认为自己独占所有计算机硬件资源,进程就是独立王国,进程间不能随便共享数据
线程就是省份,同一个进程内的线程可以共享进程的资源,每一个线程拥有自己独立的堆栈。

4 python中的进程和线程

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

两个解释器进程之间是没有任何关系的,不同进程之间是不能随便交互数据的
大多数数据都是跑在主线程上的

4 线程的状态

1 概述

1 运行态: 该时刻,该线程正在占用CPU资源
2 就绪态:可随时转换成运行态,因为其他线程正在运行而暂停,该线程不占CPU
3 阻塞态: 除非外部某些事情发生,否则线程不能运行
4 终止: 线程完成,或退出,或被取消

2 线程状态转换

python线程基础

先创建进程,然后再创建一个线程
等待资源的运行
阻塞不能直接进入运行状态,必须先进入就绪状态
运行中的线程是可以被取消的

二 python线程开发

1 Thread类

签名

def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, *, daemon=None):

参数名及含义:
target:线程调用的对象,就是目标函数
name:为线程起名字(不同线程的名字可以重复,主要是通过线程TID进行区分的)
args:为目标函数传递参数,元祖
kwargs: 为目标函数关键字传参,字典

2 实例

1 基本创建

实例如下

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
def  test():
    for i in range(5):
        print (i)
    print ('Thread over')

# 实例化一个线程
t=threading.Thread(target=test)
t.start() # 启动一个线程

python线程基础

随着函数的执行完成,线程也就结束了,子线程不结束,则主线程一直存在,此时的主线程是等待状态


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


函数执行完成,线程就退出了,如果不让线程退出,则需要使用死循环

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
def  test():
    for i in range(5):
        print (i)
    print ('Thread over')

# 实例化一个线程
t=threading.Thread(target=test,name='test1')
t.start() # 启动一个线程
t=threading.Thread(target=test,name='test2')
t.start() # 启动一个线程

# 上述两个线程是并行处理,如果是一个CPU,则是假的平衡

结果如下

python线程基础

2 线程退出

python中没有提供线程退出的方式,线程在下面情况时退出、
1 线程函数内语句执行完毕
2 线程函数中抛出未处理的异常

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
def  test():
    count=0
    while True:
        count+=1
        if  count==3:
            raise Exception('NUMBER')
        print (count)
# 实例化一个线程
t=threading.Thread(target=test,name='test1')
t.start() # 启动一个线程

异常导致的线程退出

python线程基础

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
def  test():
    count=0
    while True:
        count+=1
        if  count==3:
            raise Exception('NUMBER')
        print (count)
def test1():
    for i in range(5):
        time.sleep(0.1)
        print ('test1',i)
# 实例化一个线程
t=threading.Thread(target=test,name='test')
t.start() # 启动一个线程
t=threading.Thread(target=test1,name='test1')  #此处启用一个线程,看上述线程能否影响该线程的运行情况
t.start()

结果如下

python线程基础

python中线程没有优先级,没有线程组的概念,也不能被销毁,停止,挂起,也就没有恢复,中断了,上述的一个线程的异常不能影响另一个线程的运行,另一个线程的运行是因为其函数运行完成了

3 线程传参

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
def  test(count):
    while True:
        count+=1
        if  count==5:
            raise Exception('NUMBER')
        print (count)
# 实例化一个线程
t=threading.Thread(target=test,name='test',args=(0,))  #此处必须是元祖类型,否则会报错 
t.start() # 启动一个线程

python线程基础

4 线程相关属性

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

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
def  test(count):
    while True:
        print ("当前线程对象为{}当前处于活动的线程个数为{}".format(threading.current_thread(),threading.active_count()))
        count+=1
        if  count==5:
            break
        print (count)
    print('当前活着的线程列表为:', threading.enumerate())

# 实例化一个线程
t=threading.Thread(target=test,name='test',args=(0,))  #此处必须是元祖类型,否则会报错
t.start() # 启动一个线程
print ('当前活着的线程列表为:',threading.enumerate())

print ('当前处于活动的线程个数为{} ,当前主线程为{},当前线程ID为{}'.format(threading.active_count(),threading.main_thread(),threading.get_ident()))

结果如下

python线程基础

其线程的执行不是顺序的,其调用取决于CPU的调度规则,而主线程在子线程所有子线程退出之前都是active状态。

5 线程实例的属性和方法(getname和setname)

name : 线程的名字,只是一个标识,其可以重名,getname() 获取,setname()设置这个名词

ident:线程ID,其是非0整数,线程启动后才会有ID,否则为None,线程退出,此ID依旧可以访问,此ID可以重复使用
is_alive() 返回线程是否活着

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
def  test(count):
    while True:
        count+=1
        if  count==5:
            break
        print (count)
    print ('当前线程name 为{},ID 为{}'.format(threading.current_thread().name,threading.current_thread().ident))

# 实例化一个线程
t=threading.Thread(target=test,name='test',args=(0,))  #此处必须是元祖类型,否则会报错
t.start() # 启动一个线程
print  ('主线程状态',threading.main_thread().is_alive())
print ('线程状态',threading.current_thread().is_alive())

结果如下

python线程基础

3 start 和run 的区别与联系

1 基本概述

start() 启动线程,每一个线程必须且只能被执行一次

run() 运行线程函数

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        super().start()

    def run(self) -> None:
        print ('run',self)
        super().run()
def  work():
    print ('本线程ID为{},主线程ID为{}'.format(threading.current_thread().ident,threading.main_thread().ident))
    print ('test')

t=MyThread(target=work,name='w')
t.start()

结果如下

python线程基础

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        super().start()

    def run(self) -> None:
        print ('run',self)
        super().run()
def  work():
    print ('本线程ID为{},主线程ID为{}'.format(threading.current_thread().ident,threading.main_thread().ident))
    print ('test')

t=MyThread(target=work,name='w')
t.run()

结果如下

python线程基础

结论如下:start 方法的调用会产生新的线程,而run的调用是在主线程中运行的,且run的调用只会调用自己的方法,而start 会调用自己和run方法

2 run 和 start 调用次数问题

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        super().start()

    def run(self) -> None:
        print ('run',self)
        super().run()
def  work():
    print ('test')

t=MyThread(target=work,name='w')
t.start()
time.sleep(3)
t.start() #再次启用线程

python线程基础

上述可知,线程在start是会调用start和run属性运行,且其不能再次启动线程一次。


调用run方法

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        super().start()

    def run(self) -> None:
        print ('run',self)
        super().run()
def  work():
    print ('test')

t=MyThread(target=work,name='w')
t.run()
time.sleep(3)
t.run()

结果如下

python线程基础

run 方法也只能调用一次

3 start和run 合用

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        super().start()

    def run(self) -> None:
        print ('run',self)
        super().run()
def  work():
    print ('test')

t=MyThread(target=work,name='w')
t.run()
time.sleep(3)
t.start()

结果如下

python线程基础

上述结果表明,run和start的调用不能出现在同一个线程中

4 解决同一代码中调用问题

重新构建一个新线程并启动

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        super().start()

    def run(self) -> None:
        print ('run',self)
        super().run()
def  work():
    print ('test')

t=MyThread(target=work,name='w')
t.start()
t=MyThread(target=work,name='w1')
t.start()

结果如下

python线程基础

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        super().start()

    def run(self) -> None:
        print ('run',self)
        super().run()
def  work():
    print ('test')

t=MyThread(target=work,name='w')
t.run()
t=MyThread(target=work,name='w1')
t.run()

结果如下

python线程基础

5 run 和start 的作用

注释继承的run方法

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        super().start()

    def run(self) -> None:
        print ('run',self)
       # super().run()
def  work():
    print ('test')

t=MyThread(target=work,name='w')
t.start()
t=MyThread(target=work,name='w1')
t.start()

结果如下

python线程基础

禁用start方法

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import  time
class MyThread(threading.Thread):  # 自定义一个类,其继承Thread的相关start和run属性
    def start(self) -> None:
        print ('start',self)
        #super().start()

    def run(self) -> None:
        print ('run',self)
        super().run()
def  work():
    print ('test')

t=MyThread(target=work,name='w')
t.start()
t=MyThread(target=work,name='w1')
t.start()

python线程基础

结论:start()函数会调用run函数,而run()函数是用来运行函数的,start是创建线程的,在执行start()时run()必不可少,而在运行run()时因为不需要调用start(),因此其是非必须的。


start 会启用新的线程,其使用可以形成多线程,而run()是在当前线程中调用函数,不会产生新的线程,其均不能多次调用

4 多线程概述

一个进程中如果有多个线程,就是多线程,实现一种并发

线程的调度任务是操作系统完成的

没有开新的线程,这就是普通的函数调用,所以执行完t1.run(),然后执行t2.run(),这不是多线程

当使用start方法启动线程时,进程内有多个活动的线程并行工作,就是多线程

一个进程中至少有一个线程,作为程序的入口,这个线程就是主线程,一个进程至少有一个主线程

其他线程称为工作线程

python中的线程没有优先级的概念

5 线程安全

1 问题

此实例需要在ipython 中运行

python线程基础

此处的print 会被打断,其中间有空格,此种情况称为线程不安全。
print 函数的执行分为两步:
1 打印字符串
2 换行,就在这之间发生了线程切换,其不安全

2 解决方式:

1 通过字符串的拼接来完成

python线程基础

2 通过logging模块来处理,其输出过程中是不被打断的

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import logging # 导入日志打印模块
logging.basicConfig(level=logging.INFO)  #定义基本级别,默认是WARNING,此处修改为INFO 
def woker():
    for  x  in range(10):
        msg="{} is running".format(threading.current_thread())
        logging.info(msg)  # 日志打印 
for x  in range(5):
    t = threading.Thread(target=woker,name="work-{}".format(x)).start()

结果如下

python线程基础

简单测试的时候使用print,在其他应用的时候必须使用logging,其是针对日志打印使用的技术,日志打印过程中是不能被中断的,

6 daemon 线程和 non-daemon线程

1 概述

这里的daemon线程不是Linux中的守护进程


进程靠线程执行代码,至少一个主线程,其他线程是工作线程
主线程是第一个启动的线程
父线程: 如果线程A中启动了一个线程B,A就是B的父线程
子线程: B就是A的子线程

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

相关源码

python线程基础

此处表明。若传入的daemon 不是None,则其表示默认传入的值,否则,及若不传入,则表示使用当前线程的daemon

主线程是non-daemon线程,及daemon=False

活着线程的列表的源码

python线程基础

此处表示活着的线程列表中一定会包含主线程,

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import logging # 导入日志打印模块
logging.basicConfig(level=logging.INFO)  #定义基本级别,默认是WARNING,此处修改为INFO
def woker():
    for  x  in range(10):
        msg="{} is running".format(threading.current_thread())
        logging.info(msg)  # 日志打印

threading.Thread(target=woker,name="work-{}".format(0)).start()
print  ('ending')
print (threading.enumerate()) #主线程因为其他线程的执行,因此其处于等待状态

结果如下

python线程基础

2 daemon线程

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import logging # 导入日志打印模块
logging.basicConfig(level=logging.INFO)  #定义基本级别,默认是WARNING,此处修改为INFO
def woker():
    for  x  in range(10):
        msg="{} is running".format(threading.current_thread())
        logging.info(msg)  # 日志打印

threading.Thread(target=woker,name="work-{}".format(0),daemon=True).start() #主线程一般会在一定时间内扫描属性列表,若其中有non-daemon类型
# 的线程,则会等待其执行完成再退出,若是遇见都是daemon类型线程,则直接退出,
print  ('ending')
print (threading.enumerate()) #主线程因为其他线程的执行,因此其处于等待状态

结果如下

python线程基础

上述线程是daemon线程,因此主线程不会等待其完成后再关闭

3 non-daemon 和 damon

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import logging # 导入日志打印模块
import time
logging.basicConfig(level=logging.INFO)  #定义基本级别,默认是WARNING,此处修改为INFO
def woker():
    for  x  in range(10):
        msg="{}  {} is running".format(x,threading.current_thread())
        logging.info(msg)  # 日志打印
        time.sleep(0.5)  #此处配置延迟,检验是否在non-daemon线程执行完成后及会直接关闭的情况

threading.Thread(target=woker,name="work-{}".format(0),daemon=True).start() #主线程一般会在一定时间内扫描属性列表,若其中有non-daemon类型
# 的线程,则会等待其执行完成再退出,若是遇见都是daemon类型线程,则直接退出,、
def woker1():
    for  x  in ['a','b','c','d']:
        msg="{}  {} is running".format(x,threading.current_thread())
        logging.info(msg)  # 日志打印

threading.Thread(target=woker1,name="work-{}".format(0)).start() #主线程一般会在一定时间内扫描属性列表,若其中有non-daemon类型,则不会终止,
# 此处默认从父线程中获取属性,父线程中是non-daemon,因此此属性会一直运行,上面的会关闭,但不会影响这个

print  ('ending')
print (threading.enumerate()) #主线程因为其他线程的执行,因此其处于等待状态

结果如下

python线程基础

结果表示,当non-daemon线程执行完成后,不管damon是否执行完成,主线程将直接终止,不会再次运行。

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import logging # 导入日志打印模块
import time
def woker1():
    for  x  in ['a','b','c','d']:
        msg="{}  {} is running".format(x,threading.current_thread())
        logging.info(msg)  # 日志打印

logging.basicConfig(level=logging.INFO)  #定义基本级别,默认是WARNING,此处修改为INFO
def woker():

    for  x  in range(10):
        msg="{}  {} is running".format(x,threading.current_thread())
        logging.info(msg)  # 日志打印
        time.sleep(1)  # 此处配置1秒延时,使得主线程看不到孙子线程的non-daemon就关闭
    T3=threading.Thread(target=woker1,name="woker{}".format(10),daemon=False)  #此处启动的线程默认是non-daemon线程,但由于其父线程是daemon
    # 及就是下面的T1线程,当T2线程执行完毕后线程扫描,发现没non-daemon线程,则直接退出,此时将不会继续执行T1 的子线程T3,虽然T3是non-daemon。因为其未启动
    T3.start()

T1=threading.Thread(target=woker,name="work-{}".format(0),daemon=True)#主线程一般会在一定时间内扫描属性列表,若其中有non-daemon类型
T1.start()
# 的线程,则会等待其执行完成再退出,若是遇见都是daemon类型线程,则直接退出,

T2=threading.Thread(target=woker1,name="work-{}".format(0)) #主线程一般会在一定时间内扫描属性列表,若其中有non-daemon类型,则不会终止,
# 此处默认从父线程中获取属性,父线程中是non-daemon,因此此属性会一直运行,上面的会关闭,但不会影响这个
T2.start()
print  ('ending')
print (threading.enumerate()) #主线程因为其他线程的执行,因此其处于等待状态

结果如下

python线程基础

可能孙子线程还没起来,主线程只看到了daemon线程。则直接进行关闭,

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import logging # 导入日志打印模块
import time
def woker1():
    for  x  in ['a','b','c','d']:
        msg="{}  {} is running".format(x,threading.current_thread())
        logging.info(msg)  # 日志打印

logging.basicConfig(level=logging.INFO)  #定义基本级别,默认是WARNING,此处修改为INFO
def woker():

    for  x  in range(10):
        msg="{}  {} is running".format(x,threading.current_thread())
        logging.info(msg)  # 日志打印
        # time.sleep(1)  # 此处配置1秒延时,使得主线程看不到孙子线程的non-daemon就关闭
    T3=threading.Thread(target=woker1,name="woker{}".format(10),daemon=False)  #此处启动的线程默认是non-daemon线程,但由于其父线程是daemon
    # 及就是下面的T1线程,当T2线程执行完毕后线程扫描,发现没non-daemon线程,则直接退出,此时将不会继续执行T1 的子线程T3,虽然T3是non-daemon。因为其未启动
    T3.start()

T1=threading.Thread(target=woker,name="work-{}".format(0),daemon=True)#主线程一般会在一定时间内扫描属性列表,若其中有non-daemon类型
T1.start()
# 的线程,则会等待其执行完成再退出,若是遇见都是daemon类型线程,则直接退出,

结果如下

python线程基础

也可能是孙子线程已经起来了,主线程看到了non-daemon线程,因此未直接关闭,而是等待孙子线程执行完成后才进行关闭操作


相关属性

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


总结:

python中父线程和子线程没有直接的管理关系

python主线程是否杀掉线程,看的是daemon,若只有daemon,则直接删掉所有线程,自己结束,若还有子线程是non-daemon,则会等待

如果想让一个线程完整执行,则需要定义non-daemon属性

daemon 属性,必须在start 之前设置,否则会引发runtimeError异常

线程具有daemon属性,可以显示设置为True或False,也可以不设置,则去默认值None
如果不设置daemon,就区当前线程的daemon来设置它

主线程是non-daemon线程,及daemon=False

从主线程创建的所有线程不设置daemon属性,则默认都是daemon=False,也就是non-daemon线程

python程序在没有活着的non-daemon线程运行时推出,也就是剩下的只有daemon线程,主线程才能退出,否则主线程就只能等待。


应用场景:
不关心什么时候开始,什么时候结束的时候使用daemon,否则可以使用non-daemon

Linux的daemon是进程级别的,而python的daemon是线程级别的,其之间没有可比性的

daemon和non-daemon 启动的时候,需要注意启动的时机。


简单来说,本来并没有daemon thread,为了简化程序员工作,让他们不去记录和管理那些后台线程,创造了daemon thread 的概念,这个概念唯一的作用就是,当你把一个线程设置为daemon时,它会随着主线程的退出而退出。


主要应用场景:
1 后台任务,发送心跳包,监控,这种场景较多。
2 主线程工作才有用的线程,如主线程中维护了公共资源,主线程已经清理了,准备退出,而工作线程使用这些资源工作也没意义了,一起退出最合适
3 随时可以被终止的线程

7 join

join是标准的线程函数之一,其含义是等待,谁调用join,谁等待

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import logging # 导入日志打印模块
import time
def  foo(n):
    for i in range(n):
        print (i)
        time.sleep(0.5)
t1=threading.Thread(target=foo,args=(10,),daemon=True)
t1.start()  # 默认情况下,此线程只能执行少量此,一般不能全部执行
t1.join()  # 通过join方法将原本不能执行完成的线程执行完成了

结果如下

python线程基础

使用join方法,daemon线程执行完成后,主线程才退出,

join(timeout=None),是线程的标准方法之一。
timeout参数指定调用者等待多久,没有设置超时,则就一直等到被调用线程结束,调用谁的join方法,就是join谁,谁就要等待。

一个线程中调用另一个线程的join方法,调用者将被阻塞,直到被调用者线程终止,一个线程可以被join多次

如果在一个daemon C 线程中,对另一个daemon线程D 使用了join方法,只能说明C要等待D,主线程退出,C和D是否结束,也不管他们谁等待谁,都要被杀掉。

join 方法,支持使用等待,但其会导致多线程变成单线程,其会影响正常的运行,因此一般会将生成的线程加入到列表中,进行遍历得到对应线程进行计算。

8 threading.local 类

python 提供了threading.local 类,将这个实例化得到一个全局对象,但是不同的线程,这个对象存储的数据其他线程看不到

1 局部变量

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import time
def  worker():
    x=0  # 此处是局部变量
    for i in range(10):
        time.sleep(0.0001)
        x+=1
    print (threading.current_thread(),x)
for i in range(10):
    threading.Thread(target=worker).start()

结果如下

python线程基础

2 全局变量

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import time
x = 0  # 此处是一个全局变量
def  worker():
    for i in range(10):
        global x
        time.sleep(0.0001)
        x+=1
    print (threading.current_thread(),x)
for i in range(10):
    threading.Thread(target=worker).start()

结果如下

python线程基础

局部变量本身具有隔离效果,一旦变成全局变量,则所有的线程都将能够访问和修改。

3 使用类处理

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import time
class  A:
    def __init__(self,x):
        self.x=x
a=A(0)
def  worker():
    for i in range(100):
        a.x=0
        time.sleep(0.0001)
        a.x+=1
    print (threading.current_thread(),a.x)
for i in range(10):
    threading.Thread(target=worker).start()

结果如下

python线程基础

其不同线程的TID是不同的,可通过不同线程的TID进行为键,其结果为值,便可解决此种乱象

4 threading.local

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import time
a=threading.local()  # 做到隔离,通过TID进行数据的隔离处理不同线程的不同数值问题
def  worker():
    a.x = 0
    for i in range(100):
        time.sleep(0.0001)
        a.x+=1
    print (threading.current_thread(),a.x)
for i in range(10):
    threading.Thread(target=worker).start()

结果如下

python线程基础

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import time
a=threading.local()  # 做到隔离,通过TID进行数据的隔离处理不同线程的不同数值问题
def  worker():
    a.x = 0
    for i in range(100):
        time.sleep(0.0001)
        a.x+=1
    print (threading.current_thread(),a.x)
    print (threading.get_ident(),a.__dict__) #此处打印线程TID和字典
for i in range(10):
    threading.Thread(target=worker).start()

结果如下

python线程基础

5 源代码

python线程基础
python线程基础

self.key 是 前面的加上id
通过字典实现,线程ID的地址是唯一的,但跨进程的线程ID 不一定是相同的

进程中的线程地址可能是一样的。每一个进程都认为自己是独占资源的,但不一定就是 。

6 实践

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import time
X='abc'
ctx=threading.local()
ctx.x=123
def work():
    print (X)
    print (ctx)
    print (ctx.x)  #此时的字典中ctx此ctx.x属性,因此其不能打印,其是在线程内部,每个dict对应的值都是独立的
    print ('end')
threading.Thread(target=work).run()  # 此处是本地线程调用,则不会影响
threading.Thread(target=work).start()

结果如下

python线程基础

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import time
X='abc'
ctx=threading.local()
ctx.x=123
def work():
    print (X)
    print (ctx)
    ctx.x=100 #内部线程中定义一个局部变量,则可以执行和被调用
    print (ctx.x)  #此时的ctx 无此属性,因此其不能打印,其是在线程内部,
    print ('end')
threading.Thread(target=work).run()  # 此处是本地线程调用,则不会影响
threading.Thread(target=work).start()

结果如下

python线程基础

7 结论

threading.local类构件了一个大字典,其元素的每一线程实例的地址为Key和线程的引用线程单独的字典的映射(栈),通过threading.local 实例就可以在不同的线程中,安全的使用线程独有的数据,做到了线程间数据的隔离,如同本地变量一样

8 延迟执行Timter

1 源码

python线程基础

上述可看到,其第一个字段便是时间

2 基本实例

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import datetime
start_time=datetime.datetime.now()

def  add(x,y):
    print   (x+y)
    print("函数执行时间为{}".format((datetime.datetime.now() - start_time).total_seconds()))

t=threading.Timer(3,add,args=(3,4))
t.start()  #此处会延迟3秒执行

结果如下

python线程基础

此处是延迟执行线程,而不是延迟执行函数,本质上还是线程

3 t.cancel() 线程的删除

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import datetime
import time
def  add(x,y):
    print   (x+y)
t=threading.Timer(6,add,args=(3,4)) # 此处表示6秒后出结果
t.start()
time.sleep(5) 
t.cancel() #线程被删除

只要是没真正执行的线程,都能够被cancel删除

python线程基础

#!/usr/bin/poython3.6
#conding:utf-8
import  threading
import datetime
import time
def  add(x,y):
    time.sleep(5)
    print   (x+y)
t=threading.Timer(6,add,args=(3,4)) # 此处表示6秒后出结果
t.start()
time.sleep(10)
t.cancel()

结果如下
python线程基础

start方法后,timer对象会处于等待状态,等待interval之后,开始执行function函数,如果在执行函数之前等待阶段,使用了cancel方法,就会跳过执行函数结束。
如果线程已经开始执行了,则cancel就没有任何效果了

4 总结

Timer是线程Thread的子类,就是线程类,具有线程的能力和特征
它的实例是能够延迟执行目标函数的线程,在真正的执行目标函数之前,都可以cancel它 。