（三十三）

一、线程

是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。线程有就绪、阻塞和运行三种基本状态。

二、线程的两种创建方式

1.第一种方式

from  threading  import  Thread
  T = Thread(function,args=(arg1,arg2,...))
T.start()

2.第二种方式

from  threading  import  Thread
  Class MThread(Thread):
      Def run(self):
Pass
mt = MThread()
mt.start()

三、线程的空间

查看pid

import os
def f():
    print(os.getpid())
t = Thread(target=f,)
t.start()

2.线程空间不是隔离的

import os
def f():
    print('子线程pid:', os.getpid())#(1)
t = Thread(target=f,)
t.start()
print('主线程pid:', os.getpid())#(2)
说明：(1)、(2)两处的值是一样的。可见，线程都是在一个进程内，而一个进程都有自己独立的空间。

3.线程与进程的效率对比

（1）只是创建线程和进程

def f1():
    pass
def f2():
    pass
if __name__ == '__main__':
    t_s = time.time()
    t_lst = []
    for i in range(20):
        t = Thread(target=f1,)
        t.start()
        t_lst.append(t)

    for tt in t_lst:
        tt.join()
    t_e = time.time()

    p_s = time.time()
    p_lst = []
    for i in range(20):
        p = Process(target=f2,)
        p.start()
        p_lst.append(p)

    for pp in p_lst:
        pp.join()
    p_e = time.time()

    print('线程创建时间：', t_e - t_s)
    print('进程创建时间:', p_e - p_s)

结果：
线程创建时间： 0.004002809524536133
进程创建时间: 1.838303565979004

通过结果可以看出来，同样创建20个，线程只需要了0.004秒，也就是4毫秒，而创建进程却是1838.3毫秒。得出一个结论：进程创建过程比线程创建过程要麻烦。因为进程创建的过程是，需要在内存里开辟一个空间，把解释器代码加载进来，还需要把自己写的程序也加载进去。而线程是进程里的一个实体，只需要进程中的一点资源。所有线程共享进程中的所有资源。

（2）再来一个线程中有I/O阻塞的比较

（2）def f1():
    print('f1>>>>>aaaaa')
    time.sleep(1)
    print("f1>>>>>bbbbb")
def f2():
    print('f2>>>>>aaaaa')
    time.sleep(1)
    print("f2>>>>>bbbbb")
if __name__ == '__main__':
    t_s = time.time()
    t_lst = []
    for i in range(20):
        t = Thread(target=f1,)
        t.start()
        t_lst.append(t)

    for tt in t_lst:
        tt.join()
    t_e = time.time()

    p_s = time.time()
    p_lst = []
    for i in range(20):
        p = Process(target=f2,)
        p.start()
        p_lst.append(p)

    for pp in p_lst:
        pp.join()
    p_e = time.time()

    print('线程创建时间：', t_e - t_s)
    print('进程创建时间:', p_e - p_s)
结果：
。。。。。
线程创建时间： 1.0074326992034912
进程创建时间: 3.006932497024536

线程只是在一个进程中操作，这样就利用多道技术，实现了并发（Python中的线程不能实现多核方式，后面介绍）。进程却要创建20个，开销，时间都要比线程的多。

（3）这个是计算型的操作

def f1():
    # print('f1>>>>>aaaaa')
    # time.sleep(1)
    # print("f1>>>>>bbbbb")
    n = 10
    for i in range(10000000):
        n += i
def f2():
    # print('f2>>>>>aaaaa')
    # time.sleep(1)
    # print("f2>>>>>bbbbb")
    n = 10
    for i in range(10000000):
        n += i
if __name__ == '__main__':
    t_s = time.time()
    t_lst = []
    for i in range(5):
        t = Thread(target=f1,)
        t.start()
        t_lst.append(t)

    for tt in t_lst:
        tt.join()
    t_e = time.time()

    p_s = time.time()
    p_lst = []
    for i in range(5):
        p = Process(target=f2,)
        p.start()
        p_lst.append(p)

    for pp in p_lst:
        pp.join()
    p_e = time.time()

    print('线程操作时间：', t_e - t_s)
    print('进程操作时间:', p_e - p_s)
结果：
线程操作时间： 3.7418324947357178
进程操作时间: 2.925071954727173

好神奇啊，这次进程使用的时间短了，线程的却多了。这也是因为，线程不能使用多核技术。

四、锁

Lock

先看第一段代码：

num = 100
def f():
    global num
    tmp = num
    tmp -= 1
    time.sleep(0.01)
    num = tmp

if __name__ == '__main__':
    t_lst = []
    for i in range(10):
        t1 = Thread(target=f)
        t1.start()
        t_lst.append(t1)
    [t.join() for t in t_lst]
    print(num)

执行结果：
99

上面这段代码的作用是，想循环10次，为num每次减1，但是结果却是99。原因就是，线程执行的太快了，导致10个线程都执行到了time.sleep（0.01）这里，然后都去等着操作系统再次调用。调用到了后，再次执行赋值的操作，这样num就是99了。

为了数据安全，加把锁吧，看代码：

num = 100
def f(loc):
    global num
    loc.acquire()
    tmp = num
    tmp -= 1
    time.sleep(0.01)
    num = tmp
    loc.release()

if __name__ == '__main__':
    loc = Lock()
    t_lst = []
    for i in range(10):
        t1 = Thread(target=f,args=(loc,))
        t1.start()
        t_lst.append(t1)
    [t.join() for t in t_lst]
    print(num)
结果：
90

这次完成了心愿，结果是90了。当第一个线程拿到锁后，执行所有的操作，即便有sleep需要等待，其他9个线程也得等着，必须等着第一完成了。第一个完成后，接下来就是第二个线程，也跟第一个一样，不管其他的怎么着急，就是慢慢执行自己的。依次类推，最后结果就是90了。

2.死锁

在工作中有可能会有锁的嵌套，稍有不慎，那么就会死锁了。还是看代码：

# def f1(locA, locB):
#     locA.acquire()
#     print('f1aaaaaaaaaaaa')
#     time.sleep(0.1)
#     locB.acquire()
#     print('f1bbbbbbbbb')
#     locB.release()
#     locA.release()
# def f2(locA, locB):
#     locB.acquire()
#     print('f2--aaaaaaaa')
#     time.sleep(0.1)
#     locA.acquire()
#     print('f2--bbbbbbbb')
#     locA.release()
#     locB.release()
# if __name__ == '__main__':
#     locA = Lock()
#     locB = Lock()
#
#     t1 = Thread(target=f1, args=(locA, locB))
#     t2 = Thread(target=f2, args=(locA, locB))
#
#     t1.start()
#     t2.start()

运行后，会看到程序一直处于运行中。不会往下走了，因为线程t1等着要locB的锁，而线程t2等着要线程locA的锁，从而导致两边就这样互相等待着，程序一直不运行。

3.递归锁

为了解决死锁，Python出现了递归锁。看代码：

# def f1(locA, locB):
#     locA.acquire()
#     print('f1aaaaaaaaaaaa')
#     time.sleep(0.1)
#     locB.acquire()
#     print('f1bbbbbbbbb')
#     locB.release()
#     locA.release()
# def f2(locA, locB):
#     # locB.acquire()
#     with locB:
#         print('f2--aaaaaaaa')
#         time.sleep(0.1)
#         # locA.acquire()
#         with locA:
#             print('f2--bbbbbbbb')
#         # locA.release()
#     # locB.release()
# if __name__ == '__main__':
#     locA = locB = RLock()
#     t1 = Thread(target=f1, args=(locA, locB))
#     t2 = Thread(target=f2, args=(locA, locB))
#
#     t1.start()
#     t2.start()

递归锁，当acquire时，内部会有计数器，加1；前面acquire几次，就会记为几，当释放时，会依次再把锁释放掉。

4.GIL

这个是加载cpython解释器上的一把锁，因为它而导致Python的线程不能使用多核技术，只能串行。看图：

接下来看图说话：当我们运行了一个py文件后，其实就是启动了一个进程，操作系统就会把代码读取到内容中，并为这个进程分配相应的内存空间。在这个进程中，还会读入解释器的代码。编辑器会把这些代码处理成C语言的字节码，然后虚拟机把这些字节码再处理成二进制，这样CPU就可以处理了。

GIL锁就是加在解释器上的，每次只能有一个线程拿到这个GIL锁，其他的线程只能等待前面的把锁释放了再拿。遇到I/O阻塞的，操作系统，会把GIL锁拿回来，交给下一个线程。如果再遇到I/O阻塞还会继续拿过来交给下一个线程。这样就实现了类似单核的并发。

还有一些计算型的程序，使用线程时，第一个线程拿到了GIL锁后，会一直执行完毕。然后，操作系统把锁再交给下一个线程，这个线程还是从头执行到尾。也就是遇到计算型，中间没有I/O阻塞的程序，就是串行，一个一个线程去执行。

这里，就可以看出前面进程和线程比较时，关于时间多少的问题了。

猜你喜欢