python之线程与进程

一、操作系统与应用程序

　　在没有介绍线程与进程相关的知识之前，需要给大家引入一个知识点，关于操作系统与应用程序又与线程与进程有什么关系？

　　硬件
    ...
　　装系统
    　　系统就是一个有程序员写出来的软件,该软件用于控制计算机硬件,让他们之间相互配合
　　装软件(安装应用程序)
    　　...
　　并发与并行
    　　并发,假,由于执行速度贴别快,感觉不到停顿
    　　并行,真,创建10个人同时操作
　　线程与进程
    　　单线程与单进程
        　　一个软件默认一个进程,可以有多个
    　　线程:
        　　工作的最小单元
        　　共享进程中的所有资源
        　　每个线程可以分担一些任务，最终完成最后的结果
    　　进程:
        　　独立开辟内存
        　　进程之间的数据隔离
    　　注:GIL锁,是在进程中起到了阻塞线程的作用
　　总结:
    　　1.操作系统帮助开发者操作硬件
    　　2.程序员写好代码在操作系统上运行(依赖解释器)
    　　3.任务特别多
       　　 python多线程情况下:
            　　计算密集型操作:效率低
            　　IO操作:效率高
        　　python多进程情况下:
            　　计算密集型操作:效率高(浪费资源)
            　　IO操作:效率高(浪费资源)
        　　以后写python时:
            　　IO密集型用多线程
           　　计算密集型用多进程
        　　java多线程情况下:
            　　计算密集型操作:效率高
            　　IO操作:效率高
        　　java多进程情况下:
            　　计算密集型操作:效率高(浪费资源)
            　　IO操作:效率高(浪费资源)

    GIL锁:全局解释器锁,用于限制一个进程中间同一个时刻只有一个线程被cpu调度
    扩展:默认GIL锁在执行100个指令

二、线程与进程
　　线程是程序中一个单一的顺序控制流程。进程内有一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位
　指令运行时的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多进程。
　　
　　线程的简单示例:

 1 import time
 2     import threading
 3     def task():
 4         time.sleep(0)   #0秒也会有延迟
 5         print("拿快递")
 6     # 创建一个线程
 7     t = threading.Thread(target=task)
 8     # 执行线程
 9     t.start()
10 
11     print("干什么。。。")
12 
13     import time
14     import threading
15 
16     def task(n):
17         print("执行任务",n)
18         time.sleep(5)
19         print("...")
20         print("任务%s 执行完毕" %n)
21     while True:
22         name = input("请输入任务")
23         t = threading.Thread(target=task,args=(name,))
24         t.start()

所以说线程就像是流水线一样，走到哪里该作什么，是早已经规划好的。

　　线程的使用:

1 import threading,time
2 def num():
3     print("456")
4 t = threading.Thread(target=num)
5 t.start()
6 print("123")
7 # 运行结果
8 456
9 123

　　setDaemon方法

 1 import threading,time
 2 def sleep(arg):
 3     time.sleep(arg)
 4     print(arg)
 5 
 6 t1 = threading.Thread(target=sleep,args=(3,))
 7 t1.start()
 8 
 9 t2 = threading.Thread(target=sleep,args=(6,))
10 t2.setDaemon(True)
11 t2.start()
12 
13 print("1")
14 # 运行结果
15 # 1
16 # 3
17 # 总结，线程中的主线程默认会等其他线程执行完毕后才关闭
18 # 当设置setDaemon(True)的时候会不等

　　join方法

 1 import threading,time
 2 
 3 def join(arg):
 4     time.sleep(arg)
 5     print(arg)
 6 print("123")
 7 t1 = threading.Thread(target=join,args=(3,))
 8 t1.start()
 9 t1.join()
10 print("456")
11 #  运行结果:
12 # 123
13 # 3
14 # 456
15 # 总结:当在子线程中添加join方法(可以加参数，表示最多等多久)，则会等待子线程运行完毕后执行主线程

　　获取线程的名称相关

 1 import threading
 2 def name():
 3     t = threading.current_thread() # 获取当前线程的对象
 4     print(t.name)
 5 
 6 t1 = threading.Thread(target=name)
 7 t1.setName("amazing")
 8 t1.start()
 9 
10 t2 = threading.Thread(target=name)
11 t2.setName("Magic")
12 t2.start()
13 # 运行结果
14 # amazing
15 # Magic
16 # 总结:可以在函数中添加threading.current_thread()用来获取当前线程的对象

　　锁相关

 1 import threading,time
 2 lock = threading.RLock()  # 创建锁都对象
 3 n = 10
 4 def lk(i):
 5     print("代码不加锁",i)
 6     lock.acquire()  #加锁
 7     global n
 8     print("当前线程",i,"读取到的n值为:",n)
 9     n = i
10     time.sleep(1)
11     print("当前线程",i,"读取到的n值为:",n)
12     lock.release()  #释放锁头
13 for i in range(10):
14     t = threading.Thread(target=lk,args=(i,))
15     t.start()
16 # 总结:加完锁之后此区域的代码同一时刻只能有一个线程执行






















。。。

python之线程与进程

猜你喜欢