python---多线程threading

多线程

多任务可以由多进程完成，也可以由一个进程内的多线程完成。一个进程至少有一个线程。
由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。

由于任何进程默认就会启动一个线程，我们把该线程称为主线程，主线程又可以启动新的线程。

#创建线程
# 新线程执行的代码:
def loop():
    print('thread %s is running...' % threading.current_thread().name)
    n = 0
    while n < 5:
        n = n + 1
        print('thread %s >>> %s' % (threading.current_thread().name, n))
        time.sleep(1)
    print('thread %s ended.' % threading.current_thread().name)
#
# print('thread %s is running...' % threading.current_thread().name)
# t = threading.Thread(target=loop, name='LoopThread')
# t.start()
# t.join()
# print('thread %s ended.' % threading.current_thread().name)

多线程和多进程最大的不同，多进程中，同一个变量他们各自有拷贝存在每个进程中，互不印象，而多线程中，所有的变量都由线程共享，所以，任何一个变量都可以被任何一个线程修改。

balance = 0

def change_it(n):
    # 先存后取，结果应该为0:
    global balance
    balance = balance + n
    balance = balance - n
    # print(balance)

def run_thread(n):
    for i in range(2000000):
        change_it(n)
#阻塞了直接下一个
t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

#结果本来应该是0，但是多线程同时启动，就不一定是0了有可能混合加减了

balance = balance + n
也分两步：

计算balance + n，存入临时变量中；
将临时变量的值赋给balance。
也就是可以看成：

x = balance + n
balance = x

由于x是局部变量，两个线程各自都有自己的x，当代码正常执行时：

初始值 balance = 0

t1: x1 = balance + 5 # x1 = 0 + 5 = 5
t1: balance = x1     # balance = 5
t1: x1 = balance - 5 # x1 = 5 - 5 = 0
t1: balance = x1     # balance = 0

t2: x2 = balance + 8 # x2 = 0 + 8 = 8
t2: balance = x2     # balance = 8
t2: x2 = balance - 8 # x2 = 8 - 8 = 0
t2: balance = x2     # balance = 0
    
结果 balance = 0

但是t1和t2是交替运行的，如果操作系统以下面的顺序执行t1、t2：

# 赋值过程运行一般另外一个提前运行了并且赋值了，直到后面剩下一半执行完毕覆盖掉了
初始值 balance = 0

t1: x1 = balance + 5  # x1 = 0 + 5 = 5

t2: x2 = balance + 8  # x2 = 0 + 8 = 8
t2: balance = x2      # balance = 8

t1: balance = x1      # balance = 5
t1: x1 = balance - 5  # x1 = 5 - 5 = 0
t1: balance = x1      # balance = 0

t2: x2 = balance - 8  # x2 = 0 - 8 = -8
t2: balance = x2      # balance = -8

结果 balance = -8

锁

两个线程同时运行，会出现非理想值。如果我们要确保balance计算正确，就要给change_it()上一把锁，当某个线程开始执行change_it()时，我们说，该线程因为获得了锁，因此其他线程不能同时执行change_it()，只能等待，直到锁被释放后，获得该锁以后才能改。
由于锁只有一个，无论多少线程，同一时刻最多只有一个线程持有该锁，所以，不会造成修改的冲突。
创建一个锁就是通过threading.Lock()来实现,当多个线程同时执行lock.acquire()时，只有一个线程能成功地获取锁，然后继续执行代码，其他线程就继续等待直到获得锁为止。获得锁的线程用完后一定要释放锁，否则那些苦苦等待锁的线程将永远等待下去

balance = 0
lock = threading.Lock()

def run_thread(n):
    for i in range(100000):
        # 先要获取锁:
        lock.acquire()
        try:
            # 放心地改吧:
            change_it(n)
        finally:
            # 改完了一定要释放锁:
            lock.release()

python中使用多核cpu

如果写入一个死循环（一个死循环会百分之百占满一个cpu），并且写满多核的多个死循环，理想状态下应该占满cpu，但是python解释器不允许，任何python线程在执行前都先获得GIL锁，然后执行行100字节码，解释器再自动释放GIL锁，也就只能用到1核。多线程多核只能通过C语言去拓展了。

多线程
Python中的多线程并不是真正的多线程，python的代码有解释器进行控制的，python本身有一个全局解释器锁(GIL)，这个锁就是限制了每次只能有一个线程在运行

---

欢迎各位大佬fork、star
代码github地址：https://github.com/starSgz/pythonBase