【python】【多线程】python多线程只用了一个CPU

python的多线程不能利用多核CPU

• python的多线程写入内存速度为 2GB/s，和单线程一样
• python的多进程写入内存速度为 7GB/s
  为啥相差这么大呢？
  GIL：
  （1）在python中有一个GIL（Global Interpreter Lock）全局解释器锁。
  1、是最开始python为了数据安全设计了这个GIL。
  2、每个CPU在同一时间只能执行一个线程：
  （在单核CPU下的多线程其实都只是并发，不是并行，并发和并行从宏观上来讲都是同时处理多路请求的概念。
  但并发和并行又有区别，并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。）

（2）在python多线程下，每个线程的执行方式如下：
1、获取GIL
2、执行代码直到sleep或者是python虚拟机将其挂起。
3、释放GIL

（3）为什么有时候多线程效率低于单线程？
1、如上我们可以知道，在python中想要某个线程要执行必须先拿到GIL这把锁，且python只有一个GIL，拿到这个GIL才能进入CPU执行，
在遇到 I/O 操作时会释放这把锁。如果是纯计算的程序，没有 I/O 操作，解释器会每隔 100次操作就释放这把锁，让别的线程有机会
执行（这个次数可以通过sys.setcheckinterval 来调整）。所以虽然 CPython 的线程库直接封装操作系统的原生线程，但 CPython
进程做为一个整体，同一时间只会有一个获得了 GIL 的线程在跑，其它的线程都处于等待状态等着 GIL 的释放。
2、而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程
(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。

（4）python的多线程是否就完全没有用了呢？相同的代码，为何有时候多线程会比单线程慢，有时又会比单线程快？
这主要跟运行的代码有关：
1、CPU密集型代码(各种循环处理、计数等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到100阈值，然后触发GIL的释放与再竞争
（多个线程来回切换当然是需要消耗资源的），所以python下的多线程遇到CPU密集型代码时，单线程比多线程效率高。
2、IO密集型代码(文件处理、网络爬虫等)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在
线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。进行IO密集型的时候可以进行分时切换 所有这个时候多线程快过单线程

5、如果python想充分利用多核CPU，可以采用多进程，

每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，所以在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。
所以在多核CPU下，想做并行提升效率，比较通用的方法是使用多进程，能够有效提高执行效率。

多线程写入内存 2GB/s

# coding:utf-8
import os
import sys
import threading
from multiprocessing import Process, Queue
from multiprocessing.dummy import Pool as ThreadPool
from multiprocessing import cpu_count
import datetime
import time

how_many_thread = cpu_count()
import json


def get_memory_total():
    """获取内存的总容量(单位 MB)"""
    return int(os.popen("""free -m |grep "Mem" |awk '{print $2}' """).read().strip('\n'))


def get_memory_available():
    """获取空闲内存的总容量（不包含缓存缓冲）(单位 MB)"""
    return int(os.popen("""free -m |grep "Mem" |awk '{print $7}' """).read().strip('\n').strip(' '))


def barking_memory(full_percentage=92):
    q = Queue()
    start_mem = get_memory_available()
    start_time = time.time()
    multiprocess_fill_memory(how_many_thread, q, full_percentage)
    end_time = time.time()
    peak_mem = q.get()

    peak_mem_percent = 100 - int(100 * peak_mem / get_memory_total())
    mem_barking_report = "内存压力测试中,内存使用率{}%；程序占用的内存有{}MB；内存写入速度是{}MB/s".format(
        peak_mem_percent,
        start_mem - peak_mem,
        int((start_mem - peak_mem) / (end_time - start_time))
    )
    # print mem_barking_report
    return mem_barking_report


def multiprocess_fill_memory(process_id, q, full_percentage):
    if process_id <= 0:
        return

    # p = ThreadPool(1)
    p = threading.Thread(target=multiprocess_fill_memory, args=(process_id - 1, q, full_percentage,))
    p.start()
    main_8 = int(get_memory_available() * full_percentage // 100 // how_many_thread)
    mem = u"1" * 256 * 1024 * main_8

    if process_id == 1:
        queue_list = []
        while len(queue_list) < how_many_thread - 1:
            queue_len = q.get()
            queue_list.append(queue_len)
        peak_used_mem = get_memory_available()
        q.put(peak_used_mem)
    else:
        q.put(process_id)

    p.join()


if __name__ == '__main__':
    
    a = barking_memory()
    print(a)

多进程写入内存 7GB/s

# coding:utf-8
import os
import sys
import threading
from multiprocessing import Process, Queue
from multiprocessing.dummy import Pool as ThreadPool
from multiprocessing import cpu_count
import datetime
import time

how_many_thread = cpu_count()
import json


def get_memory_total():
    """获取内存的总容量(单位 MB)"""
    return int(os.popen("""free -m |grep "Mem" |awk '{print $2}' """).read().strip('\n'))


def get_memory_available():
    """获取空闲内存的总容量（不包含缓存缓冲）(单位 MB)"""
    return int(os.popen("""free -m |grep "Mem" |awk '{print $7}' """).read().strip('\n').strip(' '))


def barking_memory(full_percentage=92):
    q = Queue()
    start_mem = get_memory_available()
    start_time = time.time()
    multiprocess_fill_memory(how_many_thread, q, full_percentage)
    end_time = time.time()
    peak_mem = q.get()

    peak_mem_percent = 100 - int(100 * peak_mem / get_memory_total())
    mem_barking_report = "内存压力测试中,内存使用率{}%；程序占用的内存有{}MB；内存写入速度是{}MB/s".format(
        peak_mem_percent,
        start_mem - peak_mem,
        int((start_mem - peak_mem) / (end_time - start_time))
    )
    # print mem_barking_report
    return mem_barking_report


def multiprocess_fill_memory(process_id, q, full_percentage):
    if process_id <= 0:
        return

    p = Process(target=multiprocess_fill_memory, args=(process_id - 1, q, full_percentage,))
    p.start()
    main_8 = int(get_memory_available() * full_percentage // 100 // how_many_thread)
    mem = u"1" * 256 * 1024 * main_8

    if process_id == 1:
        queue_list = []
        while len(queue_list) < how_many_thread - 1:
            queue_len = q.get()
            queue_list.append(queue_len)
        peak_used_mem = get_memory_available()
        q.put(peak_used_mem)
    else:
        q.put(process_id)

    p.join()


if __name__ == '__main__':
    a = barking_memory()
    print(a)