并行程序-线程(一)

进程-内存分配单元
线程-CPU调度单元（箭头），操作系统真正调动的是线程
主线程必须等子线程结束后才会结束。
进程和线程之间的一个区别是：进程之间不共享全局变量，而线程之间共享全局变量，这是线程的一个优点，即不需要像进程一样单独通过队列等方式来共享变量，而是直接共享，但也是一个缺点。

# coding=utf-8

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)


# ---g_num=296748---
# ---test2---g_num=1348783
# ---test1---g_num=1776224


# 取消屏蔽之后
# ---test1---g_num=1000000
# ---g_num=1207917---
# ---test2---g_num=2000000

在屏蔽的情况下，为什么会出现g_num不到1000000呢？看下图

对于每个线程，加1和赋值操作是分开的两步，可能会出现如下情况：cpu先调用线程1进行加1操作，但是还没来得及进行赋值便调用线程2执行相同的加1操作，而后再分别调用1和2进行赋值操作，这期间进行了两次加1，但实际上只加了1，所以g_num最终不到2000000

如何避免上述情况，使得各线程之间不受到影响？加条件语句g_flag

这样子可以避免加1操作进行重复，但是这样就好了吗？

这样结果虽然避免了各线程之间受影响，但是效率却很低，因为g_flag=1时，满足线程1的条件，期间CPU调用线程2时，一直在判断是否满足条件g_flag !=1，这样就占用了CPU资源，做了很多无用功。

那应该如何提高CPU利用率呢？给每个线程上互斥锁

#创建锁
mutex= threading.Lock()
#锁定
mutex.acquire()
#释放
mutex.release()

一旦给一个进程上了锁，其他进程只能等待，相当于睡觉，不会占用CPU资源，因此效率会提高很多。

# coding=utf-8

from threading import Thread, Lock
import time

g_num = 0

def test1():
    global g_num
    #这个线程和ｔｅｓｔ2线程都在抢着　对这个锁　进行上锁，如果有１方成功的上锁，那么导致另外
    #一方会堵塞（一直等待）到这个锁被解开为止
    mutex.acquire()
    for i in range(1000000):
        g_num += 1
    mutex.release()#用来对mutex指向的这个锁　进行解锁，，，只要开了锁，那么接下来会让所有因为
                    #这个锁　被上了锁　而堵塞的线程　进行抢着上锁

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

def test2():
    global g_num
    mutex.acquire()
    for i in range(1000000):
        g_num += 1
    mutex.release()

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

#创建一把互斥锁，这个锁默认是没有上锁的
mutex = Lock()

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

#time.sleep(3) #取消屏蔽之后 再次运行程序，结果会不一样，，，为啥呢？

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

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

 
# ---g_num=653790---
# ---test1---g_num=1000000
# ---test2---g_num=2000000

注意：
多线程上锁，是为了让多个线程一个一个访问他们共有的资源，上锁之后，类似于单线程。那所谓的并行是指的什么呢？只指在多核的情况下，只有多核的时候，才能同时执行多个任务。

线程的同步

同步使得线程可以有序的去执行

# coding=utf-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()


# ------Task 1 -----
# ------Task 2 -----
# ------Task 3 -----
# ------Task 1 -----
# ------Task 2 -----
# ------Task 3 -----
# ------Task 1 -----
# ------Task 2 -----

总结
锁的好处：
确保了某段关键代码只能由⼀个线程从头到尾完整地执行。
锁的坏处：
阻⽌了多线程并发执⾏，包含锁的某段代码实际上只能以单线程模式执
⾏，效率就⼤⼤地下降了
由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对⽅持有
的锁时，可能会造成死锁