1.线程理论
什么是线程:线程是cpu的最小执行单位(实体),进程是操作系统的数据资源分配单位
 
2.线程的两种创建方式(重点)
查看线程的pid:使用os模块查看id,线程的id应该是相同的
3.多线程和多进程的效率对比: 
IO密集型(遇到io切换提高代码效率)和计算密集型(切换降低代码效率):切换的时候需要保存状态和切换的时间
多线程用不了多核技术,遇到纯计算的时候,多线程回避多进程的运行时间高
import time
from threading import Thread
from multiprocessing import Process
 
def f1():
    # time.sleep(1) #io密集型以后遇到的情况一遍是这样的 
    # a= 1
    # a= a+1
    # print('xxx')
    pass
if __name__ == '__main__':
    #查看一个20个多线程执行20个任务的执行时间
    t_s_time = time.time()
    t_list =[]
    for i in range(20):
        t = Thread(target=f1,)
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    t_e_time = time.time()
    t_dif_time = t_e_time - t_s_time
    #查看一下20个进程执行同样的任务的执行时间
    p_s_time = time.time()
    p_list = []
    for i in range(20):
        p = Process(target=f1, )
        p.start()
        p_list.append(p)
    [pp.join() for pp in t_list]
    p_e_time = time.time()
    p_dif_time = p_e_time - p_s_time
 
    print('多线程的执行时间:', t_dif_time)
    print('多进程的执行时间:', p_dif_time)
4.线程空间是不是隔离的:共享数据可以被更改,
import time
from threading import Thread
 
num =100
def f1(n):
    time.sleep(3)
    global num
    num= 3
    print('子线程的num',num)
 
 
if __name__ == '__main__':
    t = Thread(target=f1,args=(1,))
    t.start()
    t.join()
    print('主线程中的num',num)
 
#子线程的num 3
# 主线程中的num 3
5.守护线程
p.daemon =True  主进程的代码运行完毕,设置为守护进程的子进程会随之结束
6.锁(重点)
线程和进程的锁一样,都是牺牲了效率,保证了数据的安全
import time
from threading import Thread,Lock
 
num = 100
 
def f1(loc):
    loc.acquire()  #遇到锁,10个线程抢一个,一个进行更改数据,从并行状态更改成串行状态,牺牲的效率,保证了数据的安全
    global num   #global 只是声明变量,没有拿变量
    # num -= 1
    tmp = num
    tmp -=1
    time.sleep(0.2)
    num = tmp
    loc.release()  #解锁,把上一个更改的数据更改完成之后进行解锁,解锁之后,剩余9个在重新抢这个锁在重新更改num值,
 
 
if __name__ == '__main__':
    t_lock = Lock()
    t_list = []   #把10个线程放到一个列表,保证线程结束,主要的等待线程的结束
    for i in range(10):
        t = Thread(target=f1,args=(t_lock,))
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    print('主线程的num',num)
 
#主线程的num 90
死锁现象(重点):
两个锁进行了嵌套,一个锁包含了另一个锁
主要在数据运算\分析的时候,注意到锁跟锁嵌套的关系,容易出现死锁现象,解决这个现象问题,出现了递归锁
 
递归锁(重点) Rlock
import time
from threading import Thread,Lock,RLock
 
def f1(locA,locB):
    print('xxxx')
    time.sleep(0.1)
    locA.acquire()
    print('f1>>>1号抢到了A锁')
    time.sleep(1)
    locB.acquire()
    print('f1>>>2号抢到了B锁')
    locB.release()
    locA.release()
 
def f2(locA,locB):
    print('22222')
    time.sleep(0.1)
    locB.acquire()
    print('f2>>>1号抢到了B锁')
    time.sleep(1)
    locA.acquire()
    print('f2>>>2号抢到了A锁')
    locB.release()
    locA.release()
 
if __name__ == '__main__':
    # locA = Lock()
    # locB = Lock()
    locA = locB = RLock()   #递归锁,维护一个计数器,acquire一次加1,release一次减1,
    t1 = Thread(target=f1, args=(locA, locB))
    t2 = Thread(target=f2, args=(locA, locB))
    t1.start()
    t2.start()
    # print(t1)
    # print(t2)
递归锁,维护一个
GIL锁(重点) 
解释器上添加的锁,互斥锁造成效率不高 
计算密集型:多进程可以应用多核技术,因为每个进程里面都有解释器程序.
计算密集型的任务,由于python多线程,不能应用多核,所以效率不高,几个线程串行执行了.
io密集型的任务:多线程的任务比多进程更有优势,
 
 
 
 
 
 
 
 
 
1.线程理论
什么是线程:线程是cpu的最小执行单位(实体),进程是操作系统的数据资源分配单位
 
2.线程的两种创建方式(重点)
查看线程的pid:使用os模块查看id,线程的id应该是相同的
3.多线程和多进程的效率对比: 
IO密集型(遇到io切换提高代码效率)和计算密集型(切换降低代码效率):切换的时候需要保存状态和切换的时间
多线程用不了多核技术,遇到纯计算的时候,多线程回避多进程的运行时间高
import time
from threading import Thread
from multiprocessing import Process
 
def f1():
    # time.sleep(1) #io密集型以后遇到的情况一遍是这样的 
    # a= 1
    # a= a+1
    # print('xxx')
    pass
if __name__ == '__main__':
    #查看一个20个多线程执行20个任务的执行时间
    t_s_time = time.time()
    t_list =[]
    for i in range(20):
        t = Thread(target=f1,)
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    t_e_time = time.time()
    t_dif_time = t_e_time - t_s_time
    #查看一下20个进程执行同样的任务的执行时间
    p_s_time = time.time()
    p_list = []
    for i in range(20):
        p = Process(target=f1, )
        p.start()
        p_list.append(p)
    [pp.join() for pp in t_list]
    p_e_time = time.time()
    p_dif_time = p_e_time - p_s_time
 
    print('多线程的执行时间:', t_dif_time)
    print('多进程的执行时间:', p_dif_time)
4.线程空间是不是隔离的:共享数据可以被更改,
import time
from threading import Thread
 
num =100
def f1(n):
    time.sleep(3)
    global num
    num= 3
    print('子线程的num',num)
 
 
if __name__ == '__main__':
    t = Thread(target=f1,args=(1,))
    t.start()
    t.join()
    print('主线程中的num',num)
 
#子线程的num 3
# 主线程中的num 3
5.守护线程
p.daemon =True  主进程的代码运行完毕,设置为守护进程的子进程会随之结束
6.锁(重点)
线程和进程的锁一样,都是牺牲了效率,保证了数据的安全
import time
from threading import Thread,Lock
 
num = 100
 
def f1(loc):
    loc.acquire()  #遇到锁,10个线程抢一个,一个进行更改数据,从并行状态更改成串行状态,牺牲的效率,保证了数据的安全
    global num   #global 只是声明变量,没有拿变量
    # num -= 1
    tmp = num
    tmp -=1
    time.sleep(0.2)
    num = tmp
    loc.release()  #解锁,把上一个更改的数据更改完成之后进行解锁,解锁之后,剩余9个在重新抢这个锁在重新更改num值,
 
 
if __name__ == '__main__':
    t_lock = Lock()
    t_list = []   #把10个线程放到一个列表,保证线程结束,主要的等待线程的结束
    for i in range(10):
        t = Thread(target=f1,args=(t_lock,))
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    print('主线程的num',num)
 
#主线程的num 90
死锁现象(重点):
两个锁进行了嵌套,一个锁包含了另一个锁
主要在数据运算\分析的时候,注意到锁跟锁嵌套的关系,容易出现死锁现象,解决这个现象问题,出现了递归锁
 
递归锁(重点) Rlock
import time
from threading import Thread,Lock,RLock
 
def f1(locA,locB):
    print('xxxx')
    time.sleep(0.1)
    locA.acquire()
    print('f1>>>1号抢到了A锁')
    time.sleep(1)
    locB.acquire()
    print('f1>>>2号抢到了B锁')
    locB.release()
    locA.release()
 
def f2(locA,locB):
    print('22222')
    time.sleep(0.1)
    locB.acquire()
    print('f2>>>1号抢到了B锁')
    time.sleep(1)
    locA.acquire()
    print('f2>>>2号抢到了A锁')
    locB.release()
    locA.release()
 
if __name__ == '__main__':
    # locA = Lock()
    # locB = Lock()
    locA = locB = RLock()   #递归锁,维护一个计数器,acquire一次加1,release一次减1,
    t1 = Thread(target=f1, args=(locA, locB))
    t2 = Thread(target=f2, args=(locA, locB))
    t1.start()
    t2.start()
    # print(t1)
    # print(t2)
递归锁,维护一个
GIL锁(重点) 
解释器上添加的锁,互斥锁造成效率不高 
计算密集型:多进程可以应用多核技术,因为每个进程里面都有解释器程序.
计算密集型的任务,由于python多线程,不能应用多核,所以效率不高,几个线程串行执行了.
io密集型的任务:多线程的任务比多进程更有优势,
 
 
 
 
 
 
 
 
 

day 33 线程的更多相关文章

  1. 深入浅出 Java Concurrency (33): 线程池 part 6 线程池的实现及原理 (1)[转]

    线程池数据结构与线程构造方法 由于已经看到了ThreadPoolExecutor的源码,因此很容易就看到了ThreadPoolExecutor线程池的数据结构.图1描述了这种数据结构. 图1 Thre ...

  2. day 33 线程池有关的

    # cpu 的核心数# import os# print(os.cpu_count()) ## 爬虫的进程和线程的应用# 第一步 虚拟一个浏览器下载 在cmd 里输入 pip install requ ...

  3. day 33 线程锁

    Python的GIL锁 - Python内置的一个全局解释器锁,锁的作用就是保证同一时刻一个进程中只有一个线程可以被cpu调度. 为什么有这把GIL锁? 答:Python语言的创始人在开发这门语言时, ...

  4. python基础(33):线程(一)

    1. 线程概念的引入背景 1.1 进程 之前我们已经了解了操作系统中进程的概念,程序并不能单独运行,只有将程序装载到内存中,系统为它分配资源才能运行,而这种执行的程序就称之为进程.程序和进程的区别就在 ...

  5. Java线程:线程的同步-同步方法

    Java线程:线程的同步-同步方法   线程的同步是保证多线程安全访问竞争资源的一种手段. 线程的同步是Java多线程编程的难点,往往开发者搞不清楚什么是竞争资源.什么时候需要考虑同步,怎么同步等等问 ...

  6. Java线程:概念与原理

    Java线程:概念与原理 一.操作系统中线程和进程的概念 现在的操作系统是多任务操作系统.多线程是实现多任务的一种方式. 进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程 ...

  7. Java线程:线程状态的转换

    Java线程:线程状态的转换   一.线程状态   线程的状态转换是线程控制的基础.线程状态总的可分为五大状态:分别是生.死.可运行.运行.等待/阻塞.用一个图来描述如下:   1.新状态:线程对象已 ...

  8. java线程详解

    Java线程:概念与原理 一.操作系统中线程和进程的概念 现在的操作系统是多任务操作系统.多线程是实现多任务的一种方式. 进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程 ...

  9. Java线程详解----借鉴

    Java线程:概念与原理 一.操作系统中线程和进程的概念 现在的操作系统是多任务操作系统.多线程是实现多任务的一种方式. 进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程 ...

随机推荐

  1. C#模拟HTTP POST 请求

    GET请求: /// <summary> /// 获取accessToken /// </summary> /// <param name="corpid&qu ...

  2. zabbix安装故障点分析

    故障点分析:故障一:  2637:20151009:050431.719 [Z3001] connection to database 'zabbix' failed: [1045] Access d ...

  3. CentOS随笔 - 修改CentOS7的IP

    前言 转帖请注明出处: http://www.cnblogs.com/Troy-Lv5/ 在使用CentOS时经常我们需要固定一个IP, 因为服务器嘛,不固定IP. 难道每次都要配置开发环境的地址.? ...

  4. [枫叶学院] Unity3d高级开发教程 工具集(一) 哈希列表——强大的自己定义数据集

    在日常开发中.数据集合是我们不可缺少的重要工具之中的一个.在C#中,.Net Framework也为我们提供了种类繁多,功能多样的数据集工具.在此,我基于List<T> 和 HashTab ...

  5. BZOJ3791:作业(DP)

    Description 众所周知,白神是具有神奇的能力的. 比如说,他对数学作业说一声“数”,数学作业就会出于畏惧而自己完成:对语文作业说一声“语”,语文作业就会出于畏惧而自己完成. 今天,语文老师和 ...

  6. gluoncv 下载预训练模型速度太慢

    export MXNET_GLUON_REPO=https://apache-mxnet.s3.cn-north-1.amazonaws.com.cn https://discuss.gluon.ai ...

  7. Odoo中的模型在哪里

    Odoo 模型存在 Python 的模块之外, 在中间注册表那里. 对于这个注册表,可以通过self.env[<model name>]进入,例如, 通过res.partner 模型获取对 ...

  8. Exp6 信息收集与漏洞扫描 20164314

    一.实践目标 掌握信息搜集的最基础技能与常用工具的使用方法. 二.实践内容 1.各种搜索技巧的应用 2.DNS IP注册信息的查询 3.基本的扫描技术:主机发现.端口扫描.OS及服务版本探测.具体服务 ...

  9. 2018 HNUCM ACM集训队选拔第一场

    1.小c的倍数问题 http://acm.hdu.edu.cn/showproblem.php?pid=6108 分析: 比赛的时候真的是各种想,结果发现自己是想多了...数论基础差得一批 求有多少个 ...

  10. 过滤ST/退市股票

    nest_dict = {'code': {1: '000033', 2: '002113', 3: '002260', 4: '002512'}, 'name': {1: '新都退', 2: 'ST ...