多线程_详

多线程

什么是线程:

​ 线程不会复制主线程的空间,而是在进程内部划分一个区域,线程间能够共享资源( 会影响全局变量 ),局部变量不共享

进程与线程的区别:

进程里至少有一个线程,线程不会建立新的空间;进程会复制主进程的全部文件,开辟新的内存空间,占资源。

​ 进程 每增长一个进程就会建立一分内存空间 修改全局变量不会有影响 通讯麻烦

​ 例:儿子一出生就和老子分家,并搬出去 ,进程间资源互不影响,进程间通讯须要使用队列来传递。

​ 线程 共享内存空间 修改全局变量会影响 线程安全 互斥锁

例: 儿子一出生就和老子放假了,不过是合租。客厅( 全局 )相互公用,卧室(局部)私有。

了解线程:

demo:

# demo
import time
# 导入包
import threading


def sing(num):
    print('我在唱歌:{}次'.format(num))
    # 睡1秒
    time.sleep(1)


for i in range(10):
    # 建立线程
    t = threading.Thread(target=sing, args=(i,))
    # 开启线程
    t.start()
    # sing(i)

线程的全局变量,是不安全的,须要使用互斥锁来进行锁定状态(似: MySQL中的事务)

​ 示例:

import threading

num = 0


def add():
    # 修改全局变量
    global num
    # 开启互斥锁
    lock.acquire()
    for i in range(100000):
        num += 1
    print(f'add:{num}')
    # 关闭互斥锁
    lock.release()


def read():
    #  修改全局变量
    global num
    # 开启互斥锁
    lock.acquire()
    for i in range(100000):
        num += 1
    print(f'read:{num}')
    # 关闭互斥锁
    lock.release()


# 建立一个锁对象(只须要建立一个)
lock = threading.Lock()
# 建立一个线程
t = threading.Thread(target=add)
# 开启线程
t.start()

# 建立一个线程
t = threading.Thread(target=read)
# 开启线程
t.start()

运行结果:

若是不使用互斥锁进行锁定,当数值较小的时候可能没有太大的变化,若是大了,必有问题( 运算错误 )

Thread的继承方式

import threading


class MyThread(threading.Thread):
    # 初始化
    def __init__(self, name):
        #  继承类必需要继续初始化
        super(MyThread, self).__init__()
        self.name = name

    def run(self):  # run 是固定的
        print(f'传入的参数是:{self.name}')


def main():
    #     实例对象
    myThread = MyThread('张三')
    # 开启
    myThread.start()


if __name__ == '__main__':
    main()

继承必需要初始化继承类

继承类方式里面 的run方法是固定的,不可变!

互斥锁

互斥锁也是在threading类上,使用方法

# 建立一个锁对象(只须要建立一个)
lock = threading.Lock()

互斥锁:

​ 遵循: 原子性,惟一性

通俗的讲: 互斥锁是一个状态,当状态( 锁定 )开启时,其余的动做将不能进行操做,当解除( 解锁 )状态时,其余的能够接管继续操做.[ 主要用于线程安全 ]

死锁的解决方案:

​ 解决：添加超时时间

加锁越多,效率越慢

线程 的同步(流程执行)

案例:

import threading, time


def p1():
    # 上锁
    while True:
        if lock1.acquire():
            print('1')
            time.sleep(1)
            #     执行完成时将p2解锁
            lock2.release()


def p2():
    while True:
        if lock2.acquire():
            print('2')
            time.sleep(1)
            # p2执行完成时解锁p3
            lock3.release()


def p3():
    while True:
        if lock3.acquire():
            print('3')
            time.sleep(1)
            # p3执行完成时解锁p1
            lock1.release()


# 建立线程
t1 = threading.Thread(target=p1)
t2 = threading.Thread(target=p2)
t3 = threading.Thread(target=p3)

# 建立锁
lock1 = threading.Lock()
lock2 = threading.Lock()
lock3 = threading.Lock()
# 将p2锁住
lock2.acquire()
# 将p3锁住
lock3.acquire()

# 开启线程
t1.start()
t2.start()
t3.start()

特定环境需求,同步下不讲效率

进程：独立内存空间 资源分配的单元

线程：共享内存空间 大大减小内存的使用 线程不安全 调试单元 最后作事情的那我的

一个程序运行至少一个进程，至少一个线程

何时使用多进程，何时时候使用多线程？

IO密集型：多线程 input output

CPU密集型：多进程

编译型：c go c#

解释型：python php ruby perl js

GIL: 全局解释锁 不是PYthon特征 cpython( 解释器 ) 多线程的时候，为了保证线程自己安全，加了这个全局解释锁，

在同一时间点，只能有一个线程去CPU上执行

C语言