线程及多线程、互斥锁、死锁现象与递归锁、信号量

线程基础知识

一、什么是线程

    在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程
    进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。

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

 小结：

    进程其实不是一个执行单位，进程是一个资源单位
    每个进程内自带一个线程，线程都是cpu上的执行单位

    如果把操作系统比喻为一座工厂
        在工厂内每造出一个车间===》启动一个进程
        每个车间内至少有一条流水线===》每个进程内至少有一个线程
        线程=》单指代码的执行过程
        进程-》资源的申请与销毁的过程

进程vs线程

    1、内存共享or隔离

多个进程内空间彼此隔离
同一进程下的多个线程共享该进程内的数据

    2、创建速度

创建线程的速度远快于创建进程的速度

二、为何要用多线程？

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

    1、多线程共享一个进程的地址空间
    2、线程比进程更轻量级，线程比进程更容易创建和撤销，在许多操作系统中，创建一个线程比创建一个进程要快百倍，在需要大量线程动态和快速修改时，这一特性很有用
    3、若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会提升程序执行的速度
    4、在多cpu系统中，为了最大限度的复用多核，可以开启多个线程，比开进程开销要小的多（不限于python）

Python并发编程之多线程

一、threading模块介绍：

    multiprocess模块完全模仿了threading模块的接口，在使用层面以及相似性上差不多

二、开启进程的两种方式

# 方式一
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('主线程')

三、线程vs进程

# 1、线程的开启速度快
from threading import Thread
from multiprocess import Process
import time

def task(name):
    print('%s is running'%name)
    time.sleep(3)
    print('%s is done'%name)

if __name__=='__main__':
    t=Thread(target=task,args=('子线程',))
    # t=Process(target=task,args=('子进程',))
    t.start
    print('主')

'''
线程结果：
子线程 is running
主
'''等待3秒'''
子线程 is done

进程结果：
主
子进程 is running
'''等待3秒'''
子进程 is done
'''

# 2、同一进程下的多个线程共享该进程内的数据
from threading import Thread
import time
x=100

def task():
    global x
    x=0

if __name__ == '__main__':
    t=Thread(target=task,)
    t.start()
    # time.sleep(3)
    t.join()
    print('主',x)

'''
结果：
主 0
'''

# 3、查看pid
from threading import Thread
import time,os

def task():
    print(os.getpid())

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

线程对象的其他方法和属性

主进程等子进程是因为主进程要给子进程收尸
进程必须等待其内部所有线程都运行完毕才结束

守护线程:

守护线程会在本进程内所有非守护的线程都结束后了才跟着结束
即：
    守护线程其实守护的是整个进程的运行周期（进程内所有的非守护线程都运行完毕）

from threading import Thread,current_thread
import time


def task():
    print('%s is running' % current_thread().name)
    time.sleep(3)
    print('%s is done' % current_thread().name)


if __name__ == '__main__':
    t = Thread(target=task,name='守护线程')
    t.daemon=True
    t.start()
    print('主')
结果：
守护线程 is running
主
'''
创建线程的速度非常之快（比进程快百倍），在start时几乎同时创建的出来，所以是优先打印了%s is running
'''

from threading import Thread
import time

def foo():
    print(123)
    time.sleep(3)
    print("end123")

def bar():
    print(456)
    time.sleep(1)
    print("end456")


t1=Thread(target=foo)
t2=Thread(target=bar)

t1.daemon=True
t1.start()
t2.start()
print("main-------")

结果：
'''
123
456
main-------
end456

'''

互斥锁

# 互斥锁（mutex）
from threading import Thread,Lock
import time

mutex=Lock()

x=100
def task():
    global x
    mutex.acquire()
    temp=x
    time.sleep(0.1)
    x=temp-1
    mutex.release()

if __name__ == '__main__':
    t_l=[]
    start=time.time()
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()

    stop=time.time()
    print(x,stop-start)

'''
结果（等待了10秒后显示）：
0 10.076671123504639
'''

死锁现象与递归锁

from threading import Thread,Lock,active_count,RLock
import time

mutexA=Lock() 
mutexB=Lock()
# Obj=RLock() # 递归锁的特点：可以连续的acquire
# mutexA=obj
# mutexB=obj

class Mythread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print('%s 拿到A锁' %self.name)

        mutexB.acquire()    # ㈡ Thread-2 卡在此处，由于B锁还没有被下面的Thread-1释放
        print('%s 拿到B锁' %self.name)
        mutexB.release()

        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('%s 拿到B锁' %self.name)
        time.sleep(1)

        mutexA.acquire()    # ㈠ Thread-1卡在此处，由于A锁还没有被Thread-2释放
        print('%s 拿到A锁' %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=Mythread()
        t.start()
    print(active_count())

'''
结果：
Thread-1 拿到A锁
Thread-1 拿到B锁
Thread-1 拿到B锁
Thread-2 拿到A锁
11    ㈢ 最终卡在此处
'''

信号量

信号量是控制同一时刻并发执行的任务数

from threading import Thread,Semaphore,current_thread
import time,random

sm=Semaphore(5)

def task():
    with sm:
        print('%s 正在上厕所' %current_thread().name)
        time.sleep(random.randint(1,4))

if __name__ == '__main__':
    for i in range(20):
        t=Thread(target=task)
        t.start()