python-day34--并发编程之多线程

理论部分

一、什么是线程：

1.线程：一条流水线的工作过程 

2.一个进程里至少有一个线程，这个线程叫主线程

　　进程里真正干活的就是线程

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

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

　　共享就存在竞争，----加锁-----队列

from multiprocessing import Process
from threading import Thread
import os
import time
n=100
def work():
    global n
    n-=100

if __name__ == '__main__':
    p=Thread(target=work,)
    p.start()
    p.join()
    print('主',n)

#结果是0

二、线程的创建开销小，因而创建线程的速度快

from multiprocessing import Process
from threading import Thread
import os
import time
def work():
    print('<%s> is running' %os.getpid())
    time.sleep(2)
    print('<%s> is done' %os.getpid())

if __name__ == '__main__':
    t=Thread(target=work,)
    t.start()
    print('主',os.getpid())


结果：
<20348> is running
主 20348
<20348> is done

1.进程之间内存空间是互相隔离的

三、线程与进程的区别

　　1.线程共享创建它的进程的地址空间;进程有自己的地址空间。

　　2.线程可以直接访问其进程的数据段;进程有自己的父进程数据段的副本。（Linux系统，Windows系统也可以这么说，但是要注意Windows没有子进程的概念）

　　3.线程可以与进程的其他线程直接通信;进程必须使用进程间通信来与同级进程通信。

　　4.新线程很容易创建;新进程需要父进程的重复。

总之记住两点就ok： 1、多线程共享它们进程的资源，2、线程的创建开销小

from multiprocessing import Process
from threading import Thread
import os
import time
n=100
def work():
    global n
    n-=100

if __name__ == '__main__':
    # p=Process(target=work,)
    p=Thread(target=work,)
    p.start()
    p.join()
    print('主',n)

　　5.扩展:分布式与集中式（所有的东西放在一起）

四、为什么实用多线程：

　　1、多线程共享它们进程的资源，2、线程的创建开销小

五、多线程的应用举例

　　开启一个字处理软件进程，该进程肯定需要办不止一件事情，比如监听键盘输入，处理文字，定时自动将文字保存到硬盘，这三个任务操作的都是同一块数据，因而不能用多进程。只能在一个进程里并发地开启三个线程,如果是单线程，那就只能是，键盘输入时，不能处理文字和自动保存，自动保存时又不能输入和处理文字。　

 

代码部分

六、开启进程的两种方式：

#方式一
from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('egon',))
    t.start()
    print('主线程')

#方式二
from threading import Thread
import time
class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)


if __name__ == '__main__':
    t = Sayhi('egon')
    t.start()
    print('主线程')

七、多线程共享同一个进程内的地址空间

　　多线程共享——>竞争——>锁

八、练习

from socket import *
from threading import Thread
s=socket(AF_INET,SOCK_STREAM)
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
s.bind(('192.168.20.95',8082))
s.listen(5)
def talk(conn):
    while True:
        try:
            cmd=conn.recv(1024)
            if not cmd:break
            conn.send(cmd.upper())
        except Exception:
            break
    conn.close()

if __name__ == '__main__':
    while True:
        conn,addr=s.accept()
        p=Thread(target=talk,args=(conn,))
        p.start()
    s.close()

from socket import *
c=socket(AF_INET,SOCK_STREAM)
c.connect(('192.168.20.95',8082))

while True:
    msg=input('>>: ').strip()
    if not msg:continue
    c.send(msg.encode('utf-8'))
    data=c.recv(1024)
    print(data.decode('utf-8'))
c.close()

练习二：三个任务，一个接收用户输入，一个将用户输入的内容格式化成大写，一个将格式化后的结果存入文件

from threading import Thread
input_l=[]
format_l=[]
def talk():
    while True:
        msg=input('>>: ')
        if not msg:continue
        input_l.append(msg)
def format():
    while True:
        if input_l:
            res=input_l.pop()
            format_l.append(res.upper())
def save():
    with open('db.txt','a') as f:
        while True:
            if format_l:
                f.write('%s
' %(format_l.pop()))
                f.flush()


if __name__ == '__main__':
    t1=Thread(target=talk)
    t2=Thread(target=format)
    t3=Thread(target=save)

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

九、线程相关的其他属性及方法（了解）

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

from threading import Thread,currentThread,activeCount
import os,time,threading
def talk():
    print('%s is running' %currentThread().getName())

if __name__ == '__main__':
    # t=Thread(target=talk,name='egon')
    t=Thread(target=talk)
    t.start()
    print(t.name)
    print(t.getName())
    print(t.is_alive())
    print(currentThread().getName())
    print(threading.enumerate())
    print('主',activeCount())



#结果
Thread-1 is running
Thread-1
Thread-1
False
MainThread
[<_MainThread(MainThread, started 33752)>]
主 1

十、守护进程

　　进程： 主进程代码完——>守护死

　　线程： 主线程的非守护线程完——>守护死

十一、全局解释器锁：（GIL——CPython解释器的）

　　1.保护系统级别的（CPython解释器）代码的安全，但是不能保护用户级别的数据（软件产生的代码）安全

　　2.抢锁： 所有线程抢的是GIL锁，或者说所有线程抢的是执行权限

　　3.释放锁： ①I/O阻塞  ②运行时间过长

　　4.在一个进程中多个线程通过GIL就会变成串行的效果

　　5.有了GIL的存在，同一时刻同一进程中只有一个线程被执行

　　6.应用：

　　　　多线程用于IO密集型，如socket，爬虫，web
　　　　多进程用于计算密集型，如金融分析

十二、同步锁：

　　GIL VS Lock

　　过程分析：所有线程抢的是GIL锁，或者说所有线程抢的是执行权限

　　线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果

　　既然是串行，那我们执行

　　t1.start()

　　t1.join

　　t2.start()

　　t2.join()

　　这也是串行执行啊，为何还要加Lock呢，需知join是等待t1所有的代码执行完，相当于锁住了t1的所有代码，而Lock只是锁住一部分操作共享数据的代码。

1 分析：
2 　　#1.100个线程去抢GIL锁，即抢执行权限
3      #2. 肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()
4      #3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL
5     #4.直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

 练习：

from threading import Thread,Lock
import time
n=100
def work():
    mutex.acquire()
    global n
    temp=n
    time.sleep(0.1)
    n=temp-1
    mutex.release()

if __name__ == '__main__':
    mutex=Lock()
    t_l=[]
    for i in range(100):
        t=Thread(target=work)
        t_l.append(t)
        t.start()
    for t in t_l:
        t.join()
    print(n)