python 并发之线程

一.什么是线程

#指的是一条流水线的工作过程，关键的一句话：一个进程内最少自带一个线程，其实进程根本不能执行，进程不是执行单位，是资源的单位，分配资源的单位
#线程才是执行单位
#进程：做手机屏幕的工作过程,刚才讲的
#我们的py文件在执行的时候，如果你站在资源单位的角度来看，我们称为一个主进程，如果站在代码执行的角度来看，它叫做主线程，只是一种形象的说法，其实整个代码的执行过程成为线程，也就是干这个活儿的本身称为线程，但是我们后面学习的时候，我们就称为线程去执行某个任务，其实那某个任务的执行过程称为一个线程，一条流水线的执行过程为线程

#进程vs线程
#1 同一个进程内的多个线程是共享该进程的资源的，不同进程内的线程资源肯定是隔离的
#2 创建线程的开销比创建进程的开销要小的多

#并发三个任务：1启动三个进程：因为每个进程中有一个线程，但是我一个进程中开启三个线程就够了
#同一个程序中的三个任务需要执行，你是用三个进程好 ，还是三个线程好？
#例子：
    # pycharm 三个任务：键盘输入  屏幕输出  自动保存到硬盘
    #如果三个任务是同步的话，你键盘输入的时候，屏幕看不到
    #咱们的pycharm是不是一边输入你边看啊，就是将串行变为了三个并发的任务
    #解决方案：三个进程或者三个线程，哪个方案可行。如果是三个进程，进程的资源是不是隔离的并且开销大，最致命的就是资源隔离，但是用户输入的数据还要给另外一个进程发送过去，进程之间能直接给数据吗？你是不是copy一份给他或者通信啊，但是数据是同一份，我们有必要搞多个进程吗，线程是不是共享资源的，我们是不是可以使用多线程来搞，你线程1输入的数据，线程2能不能看到，你以后的场景还是应用多线程多，而且起线程我们说是不是很快啊，占用资源也小，还能共享同一个进程的资源，不需要将数据来回的copy！

什么是线程

进程有很多优点，它提供了多道编程，让我们感觉我们每个人都拥有自己的CPU和其他资源，可以提高计算机的利用率。很多人就不理解了，既然进程这么优秀，为什么还要线程呢？其实，仔细观察就会发现进程还是有很多缺陷的，主要体现在两点上：

• • 　　进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。

  • 　　进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行。

　　　　如果这两个缺点理解比较困难的话，举个现实的例子也许你就清楚了：如果把我们上课的过程看成一个进程的话，那么我们要做的是耳朵听老师讲课，手上还要记笔记，脑子还要思考问题，这样才能高效的完成听课的任务。而如果只提供进程这个机制的话，上面这三件事将不能同时执行，同一时间只能做一件事，听的时候就不能记笔记，也不能用脑子思考，这是其一；如果老师在黑板上写演算过程，我们开始记笔记，而老师突然有一步推不下去了，阻塞住了，他在那边思考着，而我们呢，也不能干其他事，即使你想趁此时思考一下刚才没听懂的一个问题都不行，这是其二。

　　　　现在你应该明白了进程的缺陷了，而解决的办法很简单，我们完全可以让听、写、思三个独立的过程，并行起来，这样很明显可以提高听课的效率。而实际的操作系统中，也同样引入了这种类似的机制——线程。

二.线程的出现

60年代，在OS中能拥有资源和独立运行的基本单位是进程，然而随着计算机技术的发展，进程出现了很多弊端，一是由于进程是资源拥有者，创建、撤消与切换存在较大的时空开销，因此需要引入轻型进程；二是由于对称多处理机（SMP）出现，可以满足多个运行单位，而多个进程并行开销过大。

　　　　　　因此在80年代，出现了能独立运行的基本单位——线程（Threads）。

　　　　　　注意：进程是资源分配的最小单位,线程是CPU调度的最小单位.

　　　　　　　每一个进程中至少有一个线程。　

　　　　

　　　　在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程

　　　　线程顾名思义，就是一条流水线工作的过程，一条流水线必须属于一个车间，一个车间的工作过程是一个进程

　　　　车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一个流水线

　　　　流水线的工作需要电源，电源就相当于cpu

　　　　所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。

　　　　多线程（即多个控制线程）的概念是，在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。

　　　　例如，北京地铁与上海地铁是不同的进程，而北京地铁里的13号线是一个线程，北京地铁所有的线路共享北京地铁所有的资源，比如所有的乘客可以被所有线路拉。

三.线程与进程的关系

线程与进程的区别可以归纳为以下4点：

　　　　　　1）地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。

　　　　　　2）通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。（就类似进程中的锁的作用）

　　　　　　3）调度和切换：线程上下文切换比进程上下文切换要快得多。

　　　　　　4）在多线程操作系统中（现在咱们用的系统基本都是多线程的操作系统），进程不是一个可执行的实体，真正去执行程序的不是进程，是线程，你可以理解进程就是一个线程的容器

 

四.线程的特点

　先简单了解一下线程有哪些特点，里面的堆栈啊主存区啊什么的后面会讲，大家先大概了解一下就好啦。

　　在多线程的操作系统中，通常是在一个进程中包括多个线程，每个线程都是作为利用CPU的基本单位，是花费最小开销的实体。线程具有以下属性。

　　　　1）轻型实体

　　　　　　线程中的实体基本上不拥有系统资源，只是有一些必不可少的、能保证独立运行的资源。

　　　　　　线程的实体包括程序、数据和TCB。线程是动态概念，它的动态特性由线程控制块TCB（Thread Control Block）描述。

　

TCB包括以下信息：
（1）线程状态。
（2）当线程不运行时，被保存的现场资源。
（3）一组执行堆栈。
（4）存放每个线程的局部变量主存区。
（5）访问同一个进程中的主存和其它资源。
用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。

2）独立调度和分派的基本单位。

　　　　在多线程OS中，线程是能独立运行的基本单位，因而也是独立调度和分派的基本单位。由于线程很“轻”，故线程的切换非常迅速且开销小（在同一进程中的）。

　　3）共享进程资源。

　　　　线程在同一进程中的各个线程，都可以共享该进程所拥有的资源，这首先表现在：所有线程都具有相同的进程id，这意味着，线程可以访问该进程的每一个内存资源；此外，还可以访问进程所拥有的已打开文件、定时器、信号量机构等。由于同一个进程内的线程共享内存和文件，所以线程之间互相通信不必调用内核。

　　4）可并发执行。

　　　　在一个进程中的多个线程之间，可以并发执行，甚至允许在一个进程中所有线程都能并发执行；同样，不同进程中的线程也能并发执行，充分利用和发挥了处理机与外围设备并行工作的能力。

 

五.线程的创建

1.两种方式

 from threading import Thread
 # def f1(n):
 #     print('xx%s'%n)
 #
 #
 # def f2(n):
 #     print('ss%s'%n)
 #
 #
 # if __name__ == '__main__':
 #     t = Thread(target=f1,args=(1,))
 #     t1 = Thread(target=f2,args=(2,))
 #     t.start()
 #     t1.start()

 # 第二种创建方式
 class Mythread(Thread):

     def run(self):
         print('哈哈哈')

 if __name__ == '__main__':
     t = Mythread()
     t.start()

六.多进程和多线程的效率对比

 import time
 from threading import Thread
 from multiprocessing import Process

 def f1():
     # time.sleep(1)  # io密集型 有阻塞
     # 计算型: 无阻塞
     n = 10
     for i in range(10000000):
         n = n + i

 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 p_list]

     p_e_time = time.time()

     p_dif_time = p_e_time - p_s_time

     print('多线程时间:',t_dif_time)
     print('多进程时间:',p_dif_time)

 # 计算型 多线程比多进程费时间
 # io密集型 多线程比多进程省时间

七.线程锁

1.锁

 import time
 from threading import Lock,Thread

 num = 100
 def f1(loc):
     loc.acquire()
     global num
     tmp = num
     tmp -= 1
     time.sleep(0.00001)
     num = tmp
     loc.release()

 if __name__ == '__main__':
     t_loc = Lock()
     t_list = []
     for i in range(10):
         t = Thread(target=f1,args=(t_loc,))
         t.start()
         t_list.append(t)
     [tt.join() for tt in t_list]
     print('主线成的num:',num)

2.死锁

进程也有死锁与递归锁，在进程那里忘记说了，放到这里一切说了额，进程的死锁和线程的是一样的，而且一般情况下进程之间是数据不共享的，不需要加锁，由于线程是对全局的数据共享的，所以对于全局的数据进行操作的时候，要加锁。

　　　　所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁

import time
from threading import Thread,Lock

def f1(locA,locB):
    locA.acquire()
    print('f1>>>1号抢到了A锁')
    time.sleep(1)
    locB.acquire()
    print('f1>>>1号抢到了B锁')
    locB.release()
    locA.release()
def f2(locA,locB):
    locB.acquire()
    print('f2>>>2号抢到了A锁')
    time.sleep(1)
    locA.acquire()
    print('f2>>>2号抢到了B锁')
    locA.release()
    locB.release()

if __name__ == '__main__':
    locA = locB = Lock()
    t1 = Thread(target=f1,args=(locA,locB))
    t2 = Thread(target=f2,args=(locA,locB))
    t1.start()
    t2.start()

解决方案使用递归锁

 import time
 from threading import Thread,RLock

 def f1(locA,locB):
     locA.acquire()
     print('f1>>>1号抢到了A锁')
     time.sleep(1)
     locB.acquire()
     print('f1>>>1号抢到了B锁')
     locB.release()
     locA.release()
 def f2(locA,locB):
     locB.acquire()
     print('f2>>>2号抢到了A锁')
     time.sleep(1)
     locA.acquire()
     # time.sleep(1)
     print('f2>>>2号抢到了B锁')
     locA.release()
     locB.release()

 if __name__ == '__main__':
     locA = locB = RLock()

     #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()

3.GIL锁

八.守护线程

 import time
 from threading import Thread

 def f1():
     time.sleep(2)
     print('1号线程')

 def f2():
     time.sleep(3)
     print('2号线程')

 if __name__ == '__main__':
     t1 = Thread(target=f1,)
     t2 = Thread(target=f2,)
     t1.daemon = True
     # t2.daemon = True
     t1.start()
     t2.start()
     print('主线程结束')

守护线程or守护进程区别

 import time
 from threading import Thread
 from multiprocessing import Process

 # 守护进程: 主进程代码执行运行结束,守护进程随之结束

 # 守护线程:守护线程会等待所有非守护线程运行结束才结束

 def f1(s):
     time.sleep(2)
     print('1号%s'%s)

 def f2(s):
     time.sleep(3)
     print('2号%s'%s)

 if __name__ == '__main__':
     # 多线程
     # t1 = Thread(target=f1,args=('线程',))
     # t2 = Thread(target=f2,args=('线程',))
     # t1.daemon = True  # 守护线程
     # # t2.daemon = True  # 守护线程
     # t1.start()
     # t2.start()
     # print('主线程结束')

     # 多进程
     t1 = Process(target=f1,args=('进程',))
     t2 = Process(target=f2,args=('进程',))
     # t1.daemon = True
     t2.daemon = True
     t1.start()
     t2.start()
     print('主进程结束')

守护线程:等待所有非守护线程的结束才结束

守护进程:主进程代码运行结束,守护进程就随之结束