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. php 函数func_get_args()、func_get_arg()与func_num_args()之间的区别

    php经常会有一些看似相近的函数,然而区别很大.[func_get_arg(),func_get_args(),func_num_args()]的区别,我们先看一下,下面的实例代码 从上面的结果中我们 ...

  2. Linux虚拟机将ip改为自定义模式网络

    查看当前ip:ifconfig 配置linux的ip地址:vi /etc/sysconfig/network-scripts/ifcfg-ens33 BOOTPROTO="dhcp" ...

  3. 【Oracle】查看被锁的表和解锁

    --以下几个为相关表SELECT * FROM v$lock;SELECT * FROM v$sqlarea;SELECT * FROM v$session;SELECT * FROM v$proce ...

  4. Oracle使用ODBC连接配置

    该配置是在windows 7 32位下进行的,程序已经通过了测试(使用VBS进行的测试) 1.文件下载 ------------------------------------------------ ...

  5. java获取文件大小的方法

    目前Java获取文件大小的方法有两种: 1.通过file的length()方法获取: 2.通过流式方法获取: 通过流式方法又有两种,分别是旧的java.io.*中FileInputStream的ava ...

  6. Azure 负载内部均衡器概述

    Azure 内部负载均衡器 (ILB) 仅将流量定向到云服务内的资源,或使用 VPN 来访问 Azure 基础结构. 在这一点上,ILB 与面向 Internet 的负载均衡器不同. Azure 基础 ...

  7. August 13th 2017 Week 33rd Sunday

    The best accessory a girl can own is confidence. 女生最好的饰品就是自信. Only when we have our own ideas and on ...

  8. jquery-validation验证插件

    参考网站:菜鸟教程 一.导入js <script src="http://static.runoob.com/assets/jquery-validation-1.14.0/lib/j ...

  9. struts文件上传——文件过大时错误提示的配置问题说明

    开始只在struts.xml文件中加入以下配置 <constant name="struts.multipart.maxSize" value="10000&quo ...

  10. python中基于descriptor的一些概念(下)

    @python中基于descriptor的一些概念(下) 3. Descriptor介绍 3.1 Descriptor代码示例 3.2 定义 3.3 Descriptor Protocol(协议) 3 ...