Python并发_代码007(未授权)

本文介绍: Python是运行在解释器中的语言，查找资料知道，python中有一个全局锁（GIL），在使用多线程(Thread)的情况下，不能发挥多核的优势。而使用多进程(Multiprocess)，则可以发挥多核的优势真正地提高效率。即便在多核心处理器上，使用GIL的解释器也只允许同一时间执行一个线程。

Python是运行在解释器中的语言，查找资料知道，python中有一个全局锁（GIL），在使用多线程(Thread)的情况下，不能发挥多核的优势。而使用多进程(Multiprocess)，则可以发挥多核的优势真正地提高效率。

即便在多核心处理器上，使用GIL的解释器也只允许同一时间执行一个线程。总结：（Python是一门伪多线程语言）

GIL存在目的：为了解决多线程之间数据完整性和状态同步问题

GIL存在原因：Python中对象的管理，是使用引用计数器进行的，引用数为0则释放对象（涉及到Python的垃圾回收），简化了Python对共享资源的管理，如 PVM 内存。

import requests
import time
from threading import Thread
from multiprocessing import Process


class MyProcess(multiprocessing.Process):
    """
    define my process must extends Process class
    """

    def run(self):
    """
        define work content
    """
        pass

多线程在IO密集型的操作下似乎也没有很大的优势（也许IO操作的任务再繁重一些就能体现出优势），在CPU密集型的操作下明显地比单线程线性执行性能更差，但是对于网络请求这种忙等阻塞线程的操作，多线程的优势便非常显著了。

import threading, time

class Consumer(threading.Thread):
    def __init__(self):
        pass

    def run(self):
        pass

import multiprocessing as mp


def multicore():
    pool = mp.Pool()
    res = pool.map(job, range(5)) # 定义CPU核数量为5
    print(res)
    res = pool.apply_async(job, (2,)) # 用get获得结果
    print(res.get())

def job(num):
    result = num * num
    return result

import concurrent.futures

# [rest of code]

if __name__ == "__main__":
    format = "%(asctime)s: %(message)s"
    logging.basicConfig(format=format, level=logging.INFO,
                        datefmt="%H:%M:%S")

    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        executor.map(thread_function, range(3))
#       to_wait = {executor.submit(thread_function, **kwargs): idx for idx in range(total)}

# 同步使用Lock
class FakeDatabase:
    def __init__(self):
        self.value = 0
        self._lock = threading.Lock()

    def locked_update(self, name):
        logging.info("Thread %s: starting update", name)
        logging.debug("Thread %s about to lock", name)
        with self._lock:
            logging.debug("Thread %s has lock", name)
            local_copy = self.value
            local_copy += 1
            time.sleep(0.1)
            self.value = local_copy
            logging.debug("Thread %s about to release lock", name)
        logging.debug("Thread %s after release", name)
        logging.info("Thread %s: finishing update", name)

import threading
import time

# 共享资源
shared_resource = None

# 创建条件变量
condition = threading.Condition()

# 定义一个写线程
class WriterThread(threading.Thread):
    def run(self):
        global shared_resource
        for _ in range(5):
            with condition:
                shared_resource = "Write data"
                print("Writer wrote:", shared_resource)
                condition.notify()  # 通知等待的线程
                condition.wait()  # 等待其他线程通知

# 定义一个读线程
class ReaderThread(threading.Thread):
    def run(self):
        global shared_resource
        for _ in range(5):
            with condition:
                while shared_resource is None:
                    condition.wait()  # 等待写线程通知
                print("Reader read:", shared_resource)
                shared_resource = None
                condition.notify()  # 通知写线程

# 创建写线程和读线程
writer_thread = WriterThread()
reader_thread = ReaderThread()

# 启动线程
writer_thread.start()
reader_thread.start()

# 主线程等待所有子线程结束
writer_thread.join()
reader_thread.join()

print("Main thread exiting")