day 7-6 多线程及开启方式

一. 什么是线程　　

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

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

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

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

注意：

1.所以进程里面真正干活的是线程（进程里面有线程）

2.进程只是用来把资源互相隔离开，而线程才是真正负责cpu来调动他的

二. 线程的创建开销小

创建进程的开销要远大于线程？

如果我们的软件是一个工厂，该工厂有多条流水线，流水线工作需要电源，电源只有一个即cpu（单核cpu）

一个车间就是一个进程，一个车间至少一条流水线（一个进程至少一个线程）

创建一个进程，就是创建一个车间（申请空间，在该空间内建至少一条流水线）

而建线程，就只是在一个车间内造一条流水线，无需申请空间，所以创建开销小

三. 线程与进程的区别　

　　1.创建线程比进程开销小（开一个进程，里面就有空间了，而线程在进程里面，就没必要在开一个空间了）
　　2.多线程一定是在一个进程里面开启的，共享进程里面的资源
　　3.线程启动的速度快
　　4.同一进程下的多个线程共享进程的资源，而多个进程之间内存空间是隔离的
　　如果开进程n是相互独立的，而线程是共享了资源，就不隔离了

　　在wins下开进程，子进程不会拷贝父进程的
　　在linux下开进程，子进程会完全拷贝父进程的

　　5.线程可以跟它所在的进程之内的线程通信　　

四. 为何要用到多线程　

　　多线程指的是，在一个进程中开启多个线程，简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。详细的讲分为4点：

　　1. 多线程共享一个进程的地址空间

　　2. 线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用

　　3. 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。

　　4. 在多cpu系统中，为了最大限度的利用多核，可以开启多个线程，比开进程开销要小的多。（这一条并不适用于python）

五. 开启线程的方式

 from threading import Thread

 import time

 import random

 def task(name):

     print("%s is running"%name)

     time.sleep(random.randint(1,3))

     print("%s is done"%name)

 if __name__ == '__main__':

     t1 = Thread(target=task,args=("线程",))

     t1.start()

     print("主进程....")

开线程方式一

 from threading import Thread

 import time

 import random

 class Mythread(Thread):

     def __init__(self,name):

         super().__init__()

         self.name = name

     def run(self):

         print("%s is running"%self.name)

         time.sleep(random.randint(1,3))

         print("%s is done"%self.name)

 if __name__ == '__main__':

     t1 =Mythread("子线程")

     t1.start()

     print("主线程")

开线程方式二(类方法)

注意:主进程开启后,默认会有一个线程,当运行t1子线程的时候,进程内是有2个线程的.

六. 线程和进程的开启区别

注意:线程间是平等的,并无子线程的概念.

 #1. 线程的开启速度要比进程快

 from multiprocessing import Process

 from threading import Thread

 import time

 def task(name):

     print("%s is running" %name)

     time.sleep(2)

     print("%s is done" % name)

 if __name__ == '__main__':

     # p=Process(target=task,args=("进程1",))

     # p.start()

     # print("主进程")          # 进程开启速度慢,开销大,所以向系统发出开进程的请求后,并不会立刻开启一个进程,才会先输出 "主进程",然后才能看到进程1的运行

     t = Thread(target=task,args=("线程1",))

     t.start()

     print("主进程")            # 线程开启速度快,开销小.发送开线程请求后,立刻就能开启.在线程sleep的时候,才运行"主进程"

线程和进程的开启开销

 # 2 线程和进程的数据不同

 from multiprocessing import Process

 from threading import Thread

 import time

 import os

 n=50

 def task(name):

     global n

     n = 100

     print("task",n)

 if __name__ == '__main__':

     p=Process(target=task,args=("进程1",))

     p.start()

     print("主进程",n)          # 进程间的数据是隔离的,所以主进程还是50,进程p更改了n=100,所以task的n等于100

     # t = Thread(target=task,args=("线程1",))

     # t.start()

     # print("主线程",n)            # 线程之间的数据是共享的.线程t开启后,更改了n的值,因为数据是共享的,所以主线程的n也是100

数据共享方式不同

 #3. pid不同

 from multiprocessing import Process

 from threading import Thread

 import time

 import os

 def task(name):

     # print(os.getpid())

     print(os.getpid(),os.getppid())     # 查看当前进程和父进程的pid

 if __name__ == '__main__':

     p=Process(target=task,args=("进程1",))

     p.start()

     print("主进程",os.getpid())                #2个进程,有2个不同的pid

     # t = Thread(target=task,args=("线程1",))

     # t.start()

     # print("主线程",os.getpid())

Pid不同

七. 线程的其他方法和属性

 from threading import Thread,currentThread,active_count,enumerate

 import time

 def task():

     print("%s is running"%currentThread().getName())        #获取当前线程的名字

     time.sleep(2)

     print("%s is done"%currentThread().getName())

 if __name__ == '__main__':

     t = Thread(target=task,name="线程1")

     t.start()

     t.setName("更改后的线程名")        # 输入到控制台的时候,我们会发现,running和done的名字不一样.是因为线程start后,就立刻开启了,用的名字还是"线程1",在线程1sleep

     #的时候,setname才完成更改,所以后面的done线程名和之前的不一样

     t.join()        # 等待线程1执行完毕

     print(t.is_alive())     # 查看线程是否存活,2种方法

     print(t.isAlive())

     currentThread().setName("我的主线程")        # 更改主线程的名字

     print("主线程:%s"%currentThread().getName())

     print(active_count())       #查看线程数量

     print(enumerate())          # 查看具体的线程对象,active_count方法就是len(enumerate())的结果

八. 多线程互斥锁

　　我们知道线程之间的数据是共享的,如果同时开启多个线程对同一个数据进行修改,那么发生什么样的事情呢?

 from threading import Thread,Lock

 import time

 n =100

 def task():

     global n

     temp = n

     time.sleep(0.1)

     n = temp-1

 if __name__ == '__main__':

     temp_li=[]

     for i in range(3):

         t1 = Thread(target=task)

         t1.start()

         temp_li.append(t1)

     for t in temp_li:

         t.join()

     print("main",n)

 -----------------------------------------------------------------------------------------

 　　main 99

　　最后输出的是99.为什么不是97呢?我们循环三次,开启3个线,当第一个线程运行到sleep的时候,其他线程也都运行到sleep这里了.这时候3个线程拿到的n的值都是100,所以等sleep结束后,每个线程都做了一次100-1的操作.所以最后的n就等于99了.可是这不是我们想要的结果,我们想要的是:每运行一次,n就减去1.这个时候就应该用到互斥锁了.

from threading import Thread,Lock

import time

n =100

def task(mutex):

    global n

    mutex.acquire()

    temp = n

    time.sleep(0.1)

    n = temp-1

    mutex.release()

if __name__ == '__main__':

    mutex = Lock()

    temp_li=[]

    for i in range(3):

        t1 = Thread(target=task,args=(mutex,))

        t1.start()

        temp_li.append(t1)

    for t in temp_li:

        t.join()

    print("main",n)

-----------------------------------------------------------------------------------------

    main 97

　　加上互斥锁之后,最后的n就成了97.不加互斥锁的程序运行效率比加了锁的要高.但是数据不安全,因为不加锁是并发执行的,加锁后,变成了串行执行,效率低.数据安全.

巴特西