线程

一、线程的定义

　　了解线程之前，我们先了解下进程，进程实际上不是一个执行的单位，它是一个资源单位，每个进程中都会自带一个线程，所以说线程才是cpu上的执行单位。

　　形象的理解：

　　若将操作系统比喻成一工厂

　　工厂内每建成一个车间，我们可以将之比喻为启动一个进程，在每个车间内，都至少有一条流水线，这个可比喻为每个进程内至少有一个线程，所以说，每个进程之中都至少有一个线程。

二、线程 VS 进程

1.过程的区别

　　线程是单指代码的执行过程

　　进程是负责资源空间的申请与销毁的过程

2.内存数据的共享性

　　多个进程的内存之间的空间是彼此隔离的，所以进程间是没有数据共享的。

　　同一个进程下的多个线程可以共享该进程的数据。

注意：进程与进程之间的线程数据是不共享的。

from threading import Thread

x=100
def task():
    global x
    x=0

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

# 进程的数据共享性验证方法是一样的

 

3.创建速度的比较

　　线程的创建速度要远远大于创建进程的速度。线程因为是不需要重新申请空间的，几乎是在指令刚发出去时几乎同步造好，而进程还需得向操作系统申请一个空间，所以速度会远远慢于造线程的速度。

from threading import Thread
from multiprocessing 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('main')

# 如需验证，子线程与子进程同一时间只能存在一个

4.查看pid

from threading import Thread
import time,os

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

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

# 结果证明'主线程'与'子线程'的id号是一样的

三、开启线程的两种方式

3.1 方式一

from threading import Thread,current_thread
import time

def task():
    print('%s is going' %current_thread().name)
    time.sleep(3)
    print('%s is done' %current_thread().name)
if __name__ == '__main__':
    t=Thread(target=task,args=())
    t.start()
    print('---main---')

3.2 方式二

from threading import Thread
import time

class Mythread(Thread):
    def run(self):
        print('%s is running' %self.name)
        time.sleep(3)
        print('%s is done' %self.name)

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

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

　　主进程等子进程运行结束的目的：给子进程 "收尸"。

　　而进程必须等待其内部的所有线程运行完毕才能结束。

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,)
    t.start()
    print('---main---')

from threading import Thread,current_thead,active_count,enumerate

# Thread  造线程
# current_thread 当前线程的默认名称
# active_count 活跃的线程数（包括自带的线程）
# enumerate 将活跃的线程收集起来，放至一个列表当中

五、守护线程

　　守护线程会在该进程内的所有非守护线程都运行结束之后才跟着结束。即守护线程其实守护的是整个进程的运行周期。

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设成守护线程
t1.start()
t2.start()
print("---main---")

# result（之所以没有运行 end123，是因为t1是守护线程，所有的非守护线程运行完毕之 
         #后，t1也跟着结束掉）

123
456
---main---
end456

六、互斥锁

1.互斥锁

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)

小例子的解释：

　　上述的例子中，我们并没有上锁，结果是99，为啥不是0的原因：首先，造出100个 "子线程"几乎是一瞬间的事情，因为同一个进程下的所有线程之间数据是共享的，所以它们都取到了 x=100，然后又将 x 赋值给另一个变量 temp ，在睡了0.1s之后，所有"子线程"中的 temp 都减去了1，所以我们取到的结果就是99而不是0。（我的简单理解就是各个 "子进程" 之间各自为战）　

from threading import Thread,Lock
import time

mutex=Lock()

x=100
def task():
    global x
    mutex.acquire()
    x=x-1
    time.sleep(0.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)

　　若我们将其上锁，其结果就变成了0，其原因是：在多个线程被造出来之后，几乎可以认为是第一个被造出来的线程最先抢到了锁，其他线程只能在外面等了，只有在抢到锁的线程执行完锁内的代码并"放开锁"之后，其它的线程才有机会去继续争抢锁，但是此时 x 的值已经被最先抢到锁的线程更改成了99，所以第二个抢到锁的线程取到的值就是99了，第二个抢到锁的线程再次对 x 进行更爱，以此类推，最后得到 x 的值即为0。

综上所述，互斥锁的概念就是将无序化变得有序。

2.死锁现象与递归锁

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

mutexA=Lock()
mutexB=Lock()

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

    def f1(self):
        mutexA.acquire()
        print('%s got A' %self.name)

        mutexB.acquire()
        print('%s got B' %self.name)
        mutexB.release()

        mutexA.release()

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

        mutexA.acquire()
        print('%s got A' %self.name)
        mutexA.release()

        mutexB.release()

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

　　死锁现象的解释：线程造出的速度very very fast，但同时又必须是有速度之分的，所以我们几乎可以认为是第一个线程（在这里我们称为first）最先抢到了 A 和 B （因为此时是没有竞争者出现的），当 first 将 A 和 B 从手中扔掉之后，有立马捡起了 B ，然后睡了1s,此时，其他的线程肯定是有一个线程（假装是线程二把---second）捡到了 A ，剩下的线程也只能是干瞪眼了，在 first 睡醒之后。此时问题就出现了，first 需要 second 手中的 A ，而 second 又需要 first 手中的 B，谁也不肯谦让，这时就造成了死锁现象。

from threading import Thread,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 got A' %self.name)

        mutexB.acquire()
        print('%s got B' %self.name)
        mutexB.release()

        mutexA.release()

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

        mutexA.acquire()
        print('%s got A' %self.name)
        mutexA.release()

        mutexB.release()

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

　　递归锁解决死锁的原因：递归锁是一把可以连续被同一个线程 acquire 的锁。当一个线程1捡到锁之后，会在锁上作一个标记，此时锁的引用计数为1，当线程1继续 acquire 这把锁的时候，引用计数将变成2，依次递增，此时，其余的线程均不能抢到该锁，只能在外面等待了。若线程1将锁的引用计数变成0之后，所有的线程就又可开始重新争抢这把锁了（包括线程1），但此时就不一定是线程1抢到该锁了，而是随机的，所以，由此就可解决死锁现象。

七、信号量

1.定义

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

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

sm=Semaphore(5) # 参数可以设置，此处表示最多允许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()