python网络-多线程(22)

1、什么是线程

线程（英语：thread）是操做系统可以进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运做单位。同一进程中的多条线程将共享该进程中的所有系统资源，一个进程能够有不少线程，每条线程并行执行不一样的任务。

 

2、线程和进程的区别

一、举例：

• 进程，可以完成多任务，好比 在一台电脑上可以同时运行多个QQ
• 线程，可以完成多任务，好比 一个QQ中的多个聊天窗口

二、定义的不一样

• 进程是系统进行资源分配和调度的一个独立单位.重点是资源分配和调度
• 线程是进程的一个实体,是CPU调度和分派的基本单位它是比进程更小的能独立运行的基本单位.

三、功能不一样

• 一个程序至少有一个进程,一个进程至少有一个线程.
• 线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
• 进程在执行过程当中拥有独立的内存单元，而多个线程共享内存，从而极大地提升了程序的运行效率
• 线程不可以独立执行，必须依存在进程中

四、优缺点

• 线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。

 

3、threading模块

一、单线程执行

#coding=utf-8
import time

def sayHi():
    print("Hello I am Se7eN_HOU")
    time.sleep(1)

if __name__ == "__main__":
    for i in range(5):
        sayHi()

运行结果为：

二、多线程执行

#coding=utf-8
import threading
import time

def sayHi():
    print("Hello I am Se7eN_HOU")
    time.sleep(1)

if __name__ == "__main__":
    for i in range(5):
        t = threading.Thread(target = sayHi)
        t.start()

运行结果为：

说明

1. 能够明显看出使用了多线程并发的操做，花费时间要短不少
2. 建立好的线程，须要调用start()方法来启动

三、查看线程数量

#coding=utf-8
import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)

def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)

if __name__ == '__main__':
    print("---开始---")

    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)

    t1.start()
    t2.start()

    while True:
        length = len(threading.enumerate())
        print("当前运行的线程数为：%d"%length)
        if length<=1:
            break
        sleep(0.5)

运行结果为:

 

4、Thread子类的封装

经过使用threading模块能完成多任务的程序开发，为了让每一个线程的封装性更完美，因此使用threading模块时，每每会定义一个新的子类class，只要继承threading.Thread就能够了，而后重写run方法

#coding=utf-8
import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
            print(msg)

class MyThread2(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
            print(msg)

if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()

    t1.start()
    t2.start()

运行结果为：

说明

• python的threading.Thread类有一个run方法，用于定义线程的功能函数，能够在本身的线程类中覆盖该方法。
• 建立本身的线程实例后，经过Thread类的start方法，能够启动该线程，当该线程得到执行的机会时，就会调用run方法执行线程。

2. 线程的执行顺序

#coding=utf-8
import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
            print(msg)

def test():
    for i in range(1,5):
        t=MyThread()
        t.start()

if __name__ == '__main__':
   test()

运行结果为：

说明：

从代码和执行结果咱们能够看出，多线程程序的执行顺序是不肯定的。当执行到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进入就绪（Runnable）状态，等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每一个线程都运行完整个run函数，可是线程的启动顺序、run函数中每次循环的执行顺序都不能肯定。

总结：

1. 每一个线程必定会有一个名字，尽管上面的例子中没有指定线程对象的name，可是python会自动为线程指定一个名字。
2. 当线程的run()方法结束时该线程完成。
3. 没法控制线程调度程序，但能够经过别的方式来影响线程调度的方式。

线程的几种状态

 

 

5、多线程-全局变量(共享)、局部变量(不共享)

一、共享全局变量

from threading import Thread
import time

g_num = 100

def work1():
    global g_num
    for i in range(3):
        g_num += 1
        print("----in work1, g_num is %d---"%g_num)

def work2():
    global g_num
    print("----in work2, g_num is %d---"%g_num)

print("---线程建立以前,g_num is %d---"%g_num)

t1 = Thread(target=work1)
t1.start()
#延时一会，保证t1线程中的事情作完
time.sleep(1)
t2 = Thread(target=work2)
t2.start()

运行结果为：

---线程建立以前,g_num is 100---
----in work1, g_num is 101---
----in work1, g_num is 102---
----in work1, g_num is 103---
----in work2, g_num is 103---

二、列表当作实参传递到线程中

from threading import Thread
import time

def work1(nums):
    nums.append(44)
    print("----in work1---",nums)

def work2(nums):
    #延时一会，保证t1线程中的事情作完
    time.sleep(1)
    print("----in work2---",nums)

g_nums = [11,22,33]

t1 = Thread(target=work1, args=(g_nums,))
t1.start()

t2 = Thread(target=work2, args=(g_nums,))
t2.start()

运行结果为：

----in work1--- [11, 22, 33, 44]
----in work2--- [11, 22, 33, 44]

二、不共享局部变量

import threading
from time import sleep

def test(sleepTime):
    num=1
    sleep(sleepTime)
    num+=1
    print('---(%s)--num=%d'%(threading.current_thread(), num))


t1 = threading.Thread(target = test,args=(5,))
t2 = threading.Thread(target = test,args=(1,))

t1.start()
t2.start()

运行结果为：

---(<Thread(Thread-2, started 12236)>)--num=2
---(<Thread(Thread-1, started 5644)>)--num=2

总结：

• 在一个进程内的全部线程共享全局变量，可以在不使用其余方式的前提下完成多线程之间的数据共享（这点要比多进程要好）
• 缺点就是，线程是对全局变量随意遂改可能形成多线程之间对全局变量的混乱（即线程非安全）
• 在多线程开发中，全局变量是多个线程都共享的数据，而局部变量等是各自线程的，是非共享的

 

6、同步

一、线程冲突

假设两个线程t1和t2都要对num=0进行增1运算，t1和t2都各对num修改10次，num的最终的结果应该为20。可是因为是多线程访问，有可能出现下面状况：

在num=0时，t1取得num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也得到num=0。而后t2对获得的值进行加1并赋给num，使得num=1。而后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它以前获得的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工做，但结果仍然是num=1。

from threading import Thread
import time

g_num = 0

def test1():
    global g_num
    for i in range(1000000):
        g_num += 1

    print("---test1---g_num=%d"%g_num)

def test2():
    global g_num
    for i in range(1000000):
        g_num += 1

    print("---test2---g_num=%d"%g_num)


p1 = Thread(target=test1)
p1.start()
#time.sleep(3) #取消屏蔽以后 再次运行程序，结果会不同

p2 = Thread(target=test2)
p2.start()

print("---g_num=%d---"%g_num)
time.sleep(3)
print("---g_num=%d---"%g_num)

运行结果为：

---g_num=138526---
---test1---g_num=1264273
---test2---g_num=1374945
---g_num=1374945---

取消屏蔽以后，再次运行结果以下：

---test1---g_num=1000000
---g_num=1029220---
---test2---g_num=2000000
---g_num=2000000---

问题产生的缘由就是没有控制多个线程对同一资源的访问，对数据形成破坏，使得线程运行的结果不可预期。这种现象称为“线程不安全”。

2. 什么是同步

• 同步就是协同步调，按预约的前后次序进行运行。如:你说完，我再说。
• "同"字从字面上容易理解为一块儿动做，其实不是，"同"字应是指协同、协助、互相配合。
• 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到必定程度时要依靠B的某个结果，因而停下来，示意B运行;B依言执行，再将结果给A;A再继续操做。

3. 解决问题的思路

对于上面提出的那个计算错误的问题，能够经过线程同步来进行解决思路，以下:

1. 系统调用t1，而后获取到num的值为0，此时上一把锁，即不容许其余如今操做num
2. 对num的值进行+1
3. 解锁，此时num的值为1，其余的线程就可使用num了，并且是num的值不是0而是1
4. 同理其余线程在对num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程当中不容许其余线程访问，就保证了数据的正确性

 

7、线程互斥锁

1、线程互斥锁介绍

当多个线程几乎同时修改某一个共享数据的时候，须要进行同步控制，线程同步可以保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁为资源引入一个状态：锁定/非锁定

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其余线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其余的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操做，从而保证了多线程状况下数据的正确性。

threading模块中定义了Lock类，能够方便的处理锁定：

#建立锁
mutex = threading.Lock()
#锁定
mutex.acquire([blocking])
#释放
mutex.release()

其中，锁定方法acquire能够有一个blocking参数。

• 若是设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止（若是没有指定，那么默认为True）
• 若是设定blocking为False，则当前线程不会堵塞

使用互斥锁实现上面的例子的代码以下：

from threading import Thread, Lock
import time

g_num = 0

def test1():
    global g_num
    for i in range(1000000):
        #True表示堵塞 即若是这个锁在上锁以前已经被上锁了，那么这个线程会在这里一直等待到解锁为止 
        #False表示非堵塞，即无论本次调用可以成功上锁，都不会卡在这,而是继续执行下面的代码
        mutexFlag = mutex.acquire(True) 
        if mutexFlag:#锁住
            g_num += 1
            mutex.release()#解锁
    print("---test1---g_num=%d"%g_num)

def test2():
    global g_num
    for i in range(1000000):
        mutexFlag = mutex.acquire(True) #True表示堵塞
        if mutexFlag:#锁住
            g_num += 1
            mutex.release()#解锁
    print("---test2---g_num=%d"%g_num)

#建立一个互斥锁
#这个所默认是未上锁的状态
mutex = Lock()

p1 = Thread(target=test1)
p1.start()


p2 = Thread(target=test2)
p2.start()

time.sleep(5)
print("---g_num=%d---"%g_num)

运行结果为：

---test1---g_num=1942922
---test2---g_num=2000000
---g_num=2000000---

二、上锁解锁过程

• 当一个线程调用锁的acquire()方法得到锁时，锁就进入“locked”状态。
• 每次只有一个线程能够得到锁。若是此时另外一个线程试图得到这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁以后，锁进入“unlocked”状态。
• 线程调度程序从处于同步阻塞状态的线程中选择一个来得到锁，并使得该线程进入运行（running）状态。

总结

锁的好处：

• 确保了某段关键代码只能由一个线程从头至尾完整地执行

锁的坏处：

• 阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地降低了
• 因为能够存在多个锁，不一样的线程持有不一样的锁，并试图获取对方持有的锁时，可能会形成死锁

三、死锁

在线程间共享多个资源的时候，若是两个线程分别占有一部分资源而且同时等待对方的资源，就会形成死锁。

尽管死锁不多发生，但一旦发生就会形成应用的中止响应。下面看一个死锁的例子

#coding=utf-8
import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        if mutexA.acquire():
            print(self.name+'----do1---up----')
            time.sleep(1)

            if mutexB.acquire():
                print(self.name+'----do1---down----')
                mutexB.release()
            mutexA.release()

class MyThread2(threading.Thread):
    def run(self):
        if mutexB.acquire():
            print(self.name+'----do2---up----')
            time.sleep(1)
            if mutexA.acquire():
                print(self.name+'----do2---down----')
                mutexA.release()
            mutexB.release()

mutexA = threading.Lock()
mutexB = threading.Lock()

if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

运行结果为：

Thread-1----do1---up----
Thread-2----do2---up----

此时已经进入到了死锁状态

 

 

四、 避免死锁

• 程序设计时要尽可能避免（银行家算法）
• 添加超时时间等

 

8、同步应用

from threading import Thread,Lock
from time import sleep

class Task1(Thread):
    def run(self):
        while True:
            if lock1.acquire():
                print("------Task 1 -----")
                sleep(0.5)
                lock2.release()

class Task2(Thread):
    def run(self):
        while True:
            if lock2.acquire():
                print("------Task 2 -----")
                sleep(0.5)
                lock3.release()

class Task3(Thread):
    def run(self):
        while True:
            if lock3.acquire():
                print("------Task 3 -----")
                sleep(0.5)
                lock1.release()

#使用Lock建立出的锁默认没有“锁上”
lock1 = Lock()
#建立另一把锁，而且“锁上”
lock2 = Lock()
lock2.acquire()
#建立另一把锁，而且“锁上”
lock3 = Lock()
lock3.acquire()

t1 = Task1()
t2 = Task2()
t3 = Task3()

t1.start()
t2.start()
t3.start()

运行结果为：

可使用互斥锁完成多个任务，有序的进程工做，这就是线程的同步

 

9、ThreadLocal

在多线程环境下，每一个线程都有本身的数据。一个线程使用本身的局部变量比使用全局变量好，由于局部变量只有线程本身能看见，不会影响其余线程，而全局变量的修改必须加锁。

import threading

# 建立全局ThreadLocal对象:
local_school = threading.local()

def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=("Se7eN",), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=("HOU",), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

运行结果为：

Hello, Se7eN (in Thread-A)
Hello, HOU (in Thread-B)

说明：

1. 全局变量local_school就是一个ThreadLocal对象，每一个Thread对它均可以读写student属性，但互不影响。你能够把local_school当作全局变量，但每一个属性如local_school.student都是线程的局部变量，能够任意读写而互不干扰，也不用管理锁的问题，ThreadLocal内部会处理。
2. ThreadLocal最经常使用的地方就是为每一个线程绑定一个数据库链接，HTTP请求，用户身份信息等，这样一个线程的全部调用到的处理函数均可以很是方便地访问这些资源。
3.  一个ThreadLocal变量虽然是全局变量，但每一个线程都只能读写本身线程的独立副本，互不干扰。ThreadLocal解决了参数在一个线程中各个函数之间互相传递的问题

 

10、异步

• 同步调用就是你 喊 你朋友吃饭 ，你朋友在忙 ，你就一直在那等，等你朋友忙完了 ，大家一块儿去
• 异步调用就是你 喊 你朋友吃饭 ，你朋友说知道了 ，待会忙完去找你 ，你就去作别的了。

def test():
    print("---进程池中的进程---pid=%d,ppid=%d--"%(os.getpid(),os.getppid()))
    for i in range(3):
        print("----%d---"%i)
        time.sleep(1)
    return "hahah"

def test2(args):
    print("---callback func--pid=%d"%os.getpid())
    print("---callback func--args=%s"%args)
   
pool = Pool(3)
pool.apply_async(func=test,callback=test2)
time.sleep(5)
print("----主进程-pid=%d----"%os.getpid())

运行结果为：

---进程池中的进程---pid=9401,ppid=9400--
----0---
----1---
----2---
---callback func--pid=9400
---callback func--args=hahah
----主进程-pid=9400----

 11、并行和并发

不管是并行仍是并发，在用户看来都是'同时'运行的，无论是进程仍是线程，都只是一个任务而已，真是干活的是cpu，cpu来作这些任务，而一个cpu同一时刻只能执行一个任务。

并发是伪并行，即看起来是同时运行。单个cpu+多道技术就能够实现并发，（并行也属于并发），简单的能够理解为快速在多个线程来回切换，感受好像同时在作多个事情。

只有具有多个cpu才能实现并行，单核下，能够利用多道技术，多个核，每一个核也均可以利用多道技术（多道技术是针对单核而言的）。          

有四个核，六个任务，这样同一时间有四个任务被执行，假设分别被分配给了cpu1，cpu2，cpu3，cpu4，一旦任务1遇到I/O就被迫中断执行，此时任务5就拿到cpu1的时间片去执行，这就是单核下的多道技术 ，而一旦任务1的I/O结束了，操做系统会从新调用它(需知进程的调度、分配给哪一个cpu运行，由操做系统说了算)，可能被分配给四个cpu中的任意一个去执行。

　　多道技术：内存中同时存入多道（多个）程序，cpu从一个进程快速切换到另一个，使每一个进程各自运行几十或几百毫秒，这样，虽然在某一个瞬间，一个cpu只能执行一个任务，但在1秒内，cpu却能够运行多个进程，这就给人产生了并行的错觉，即伪并发，以此来区分多处理器操做系统的真正硬件并行（多个cpu共享同一个物理内存）

• 同步执行：一个进程在执行某个任务时，另一个进程必须等待其执行完毕，才能继续执行
• 异步执行：一个进程在执行某个任务时，另一个进程无需等待其执行完毕，就能够继续执行，当有消息返回时，系统会通知后者进行处理，这样能够提升执行效率

    举个例子，打电话时就是同步通讯，发短息时就是异步通讯。