Python进阶:深入GIL(上篇)

TMS320F28377D双核开发例程 - DSP开发 首先,我们需要创建一个新的工程来进行开发。然后,选择适当的目标设备为TMS320F28377D,并设置工程的名称和存储位置。在上面的代码中,我们定义了一个128个元素的输入数组和输出数组。然后,我们使用一个简单的数字信号处理算法,将输入数组中的每个元素平方,并将结果存储到输出数组中。这个芯片的双核架构提供了更高的计算能力和灵活性,使得数字信号处理的开发更加高效和可靠。希望本文对您有所帮助!当应用程序在TMS320F28377D芯片上运行时,它将对输入数组中的每个元素进行平方运算,并将结果打印出来。 阅读详情

Python进阶:深入GIL(上篇)

HackPython致力于有趣有价值的编程教学

简介

熟悉Python的人理应都听过GIL(Global Interpreter Lock,全局解释器锁)?,大概也知道它就是造成Python多线程并发其实是「伪并行」的核心原因,但依旧很多人没有深入其中,所以HackPython尝试以上、下两篇文章来阐释GIL,分别从其表现现象、对应源码以及Python对GIL改进等方面进行讨论?。

线程与进程

在讨论GIL前,先通过简单的文字描述一下线程与进程并理解其中的关系。

当我们启动一个程序时,系统中就至少启动了一个对应的进程,即一个程序至少对应一个进程?。所谓程序,它其实是一种静态的资源实体,就是一堆代码,存在于硬盘中,本身没有任何运行的含义,而进程是动态的,它是程序操作某个数据集时的动态实体,存在于内存中?。

一个进程可以包含多个线程,这些线程可以共享当前进程中的内存空间?,这种特性就出现了线程不安全的概念,即多个线程同时使用了一个空间,导致程序逻辑错误?,常见的方式就是使用锁或信号量等机制来限制公共资源的使用?。

Python多线程的伪并行

Python中可以使用「threading」模块来创建并使用多线程,为了直观比较,先试一下一个没有使用多线程的代码?,如下:

import time

def add(n):
    sum = 0
    while sum <= n:
        sum += 1
    print(f'sum:{sum}')

if __name__ == '__main__':
    start = time.time()
    add(500000000)
    print('run time: %s'%str(time.time() - start))

代码非常简单,就是一个add()方法一直做累加操作,运行结果为?:

python 5.py
sum:500000001
run time: 23.80576515197754

那我使用多线程效果会不会好一些呢?凭感觉直观而言,应该是会的?,因为上面的程序只使用了一个线程,那我开两个线程,让其同时工作,其运行时间应该短一半才对?,但事实时使用多线程后,运行时间依旧没有变动?,多线程版本的代码如下:

import threading, time

def add(n):
    sum = 0
    while sum <= n:
        sum += 1
    print(f'sum:{sum}')

if __name__ == '__main__':
    start = time.time()
    n = 500000000
    t1 = threading.Thread(target=add, args=[n//2])
    t2 = threading.Thread(target=add, args=[n//2])
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print('run time: %s'%str(time.time() - start))

为了让相加的数量相近,这里每个线程只需要执行「n//2」次,使用join的目的是得等线程运行完后,再执行后续的逻辑,这里只是为了方便记录运行时间?。运行结果如下:

python 6.py
sum:250000001
sum:250000001
run time: 23.04693603515625

发现跟一开始单线程的程序在运行时间上没有什么差异,而造成这种现象的原因就是GIL?,需要注意的是,GIL只存在于通过C语言实现的Python解释器上,即CPython上?,后人为了绕过GIL的问题利用Java开发了Jpython或使用Python自己开发了自己的解释器PyPy,这些上都不存在GIL全局解释器锁的问题?,但CPython才是当前最多人使用的主流Python解释器?。

在CPython中,每一个Python线程执行前都需要去获得GIL锁?,获得该锁的线程才可以执行,没有获得的只能等待?,当具有GIL锁的线程运行完成后,其他等待的线程就会去争夺GIL锁,这就造成了,在Python中使用多线程,但同一时刻下依旧只有一个线程在运行?,所以Python多线程其实并不是「并行」的,而是「并发」?。

看到下图,图中是Python中GIL的工作实例,其中有3个线程,线程与线程之间是顺序执行的?,每个线程开始执行时都会去获得GIL,防止其他线程线程运行?,每执行完一段时间后,就会释放GIL,让别的线程可以去争夺执行权限,如果自己本身也没有执行完,则本身也会参与这次争夺?。

可以发现,Python中的线程工作一段时间后,会主动释放GIL,这是为了让其他线程都有机会执行?,而释放的时机就涉及到了「检查间隔」(check interval)机制?,在早期版本的Python中,检查机制是100ticks,而Python3后,每15毫米使用一次检查间隔,然后就会释放GIL锁?。

但需要注意的是线程有了GIL后并不意味着使用Python多线程时不需要考虑线程安全?,「GIL的存在是为了方便使用C语言编写CPython解释器的编写者,而顶层使用Python时依旧要考虑线程安全」?,在下一篇中会从原始编码层面来解释存在GIL后,依旧会有线程不安全现象的原因。

多进程实现并行

GIL的存在让Python多线程在运行CPU密集型性程序时显得非常无力,为了绕过GIL的限制,一种简单的方法就是使用多进程?,这是因为GIL只会存在于线程级别,即一个进程为了确保某一时刻下只有一个线程在运行,才使用GIL?,但多个进程之间并不会出现这种限制,不同的进程会运行在CPU不同的核上,实现真正的「并行」?。

通过进程的方式将上面的任务再执行一遍,看一下运行时长,具体代码如下:

from multiprocessing import Process
import time

def add(procname, n):
    sum = 0
    while sum <= n:
        sum += 1
    print(f'process name: {procname}')
    print(f'sum: {sum}')

if __name__ == '__main__':
    start = time.time()
    n = 500000000
    p1 = Process(target=add, args=('Proc-1',n//2))
    p2 = Process(target=add, args=('Proc-2',n//2))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print('run time: %s'%str(time.time() - start))

Python中多进程可以使用 multiprocessing 这个库,使用方法与使用线程类似?,代码中启用了两个进程,分别运行 n//2 数据量的数据,其结果如下:

python 7.py
process name: Proc-1
sum: 250000001
process name: Proc-2
sum: 250000001
run time: 12.768253087997437

从结果可以看出,时间确实减少了一半左右,多进程状态下确实是真正的「并行」。

如何绕过GIL?

有了多进程后,大部分程序都可以通过多进程的方式绕过GIL?,但如果依旧不满足,就需要使用C/C++来实现这部分代码,并生成对应的so或dll文件,再通过Python的ctypes将其调用起来?,Python中很多对计算性能有较高要求的库都采用了这种方式,如Numpy、Pandas等等?。

如果你对程序的性能要求的特别严格,此时更好的方法是选择其他语言?。

结尾

本节简单的讨论了Python中GIL相关的内容,在下一篇中会从代码层面再次深入的讨论GIL的相关内容,欢迎学习 HackPython 的教学课程并感觉您的阅读与支持。

??

参考文章:

David Beazley 的Understanding the Python GIL

Y-Branch and a closed y-branch loop 双臂后面的区域,我们将它的双臂使用一个波导进行了连接,使得它本身形成了一个闭合回路,因此,该结构被称作。它们均是用来对经过它们的光束能量进行分割的一种器件。首先,我们知道一点,在光波导层面,今天给大家介绍一下,什么是。 阅读详情

相关推荐

多台树莓派(主机)通信

在做无人机实验时,有个任务需要 两台无人机 或 无人机与小车 进行通信。 由于我们飞机上用了树莓派,相当于一台电脑,索性选用Socket网络编程。 条件:树莓派、局域网(手机热点或路由器)。需要通信的两台树莓派接入同一个局域网。 如若现场没有网络,可将树莓派配置为无线路由器,发射wifi。网上很多教程,注意一点是树莓派需要先用网线接入路由器再配置。 发送数据: # -*- coding...

LNL_LNL的博客 7690

Python中的GIL(全局解释器锁)详解

能执行Python字节码。其核心目的是简化内存管理(如引用计数)并避免多线程环境下的数据竞争和内存错误。

m0_65482549的博客 2060

AD620仪表放大器模组实战:从调零到信号放大的完整指南

本文详细介绍了AD620仪表放大器模组的实战应用,从调零到信号放大的完整指南。AD620模组以其专业级性能和易用性成为微弱信号放大的首选,集成了AD620芯片、LM358运放和7660电源转换芯片。文章提供了调零技巧、增益设置方法以及单端与差分输入的正确连接方案,并通过心电信号采集和称重传感器等实际案例展示了其广泛应用。

weixin_29290379的博客 379

python GLI锁机制

什么是GLI? Python中的线程是操作系统的原生线程,Python虚拟机使用一个全局解释器锁(Global Interpreter Lock)来互斥线程对Python虚拟机的使用。为了支持多线程机制,一个基本的要求就是需要实现不同线程对共享资源访问的互斥,所以引入了GIL。由于GLI的存在,一个线程拥有了解释器的访问权之后,其他的所有线程都必须等待它释放解释器的访问权,即使这些线程的下一条指...

weixin_30821731的博客 346

Hadoop与Kafka集群部署与优化实践指南

分布式系统是现代大数据处理的核心架构,其中Hadoop作为分布式存储与计算框架,Kafka作为分布式消息队列系统,共同构成了实时数据处理的基础设施。通过HDFS实现海量数据存储,结合YARN进行资源调度,而Kafka则保障了数据流的实时传输与高吞吐。这种技术组合在电商用户行为分析、物联网数据采集等场景中表现卓越。部署过程中需关注硬件资源配置、关键参数调优以及集群监控方案,例如通过调整HDFS块大小和Kafka partition数量来优化性能。合理运用Flume、Spark Streaming等工具可实现系

weixin_29061997的博客 363

第十六章:载板制造工艺大全

本文详细介绍了IC载板制造的完整工艺流程,主要包括开料、钻孔、孔金属化、图形形成、层压、表面处理、成型和电测8大工序。每个工序都列出了关键参数和质量控制要点,如开料尺寸精度±0.1mm、激光钻孔孔径50-150μm、孔金属化铜厚20-30μm、图形形成线宽15μm±2μm等。文中还特别说明了MSAP工艺和沉金等特殊工艺的详细流程,以及成型精度和电测标准等关键指标。全文通过流程图和参数表格直观展示了IC载板制造的核心工艺和质量要求。

Open 186

python可以启动多少线程_今天来讲讲python(GLI)

什么是GLI?Python中的线程是操作系统的原生线程,Python虚拟机使用一个全局解释器锁(Global Interpreter Lock)来互斥线程对Python虚拟机的使用。为了支持多线程机制,一个基本的要求就是需要实现不同线程对共享资源访问的互斥,所以引入了GIL。由于GLI的存在,一个线程拥有了解释器的访问权之后,其他的所有线程都必须等待它释放解释器的访问权,即使这些线程的下一条指令并...

weixin_39672443的博客 393

深度解析大众点评反爬机制:构建高可用店铺评论采集系统(2026最新实战)

在中文互联网数据采集领域,大众点评(现归属美团)始终占据着特殊地位。其丰富的UGC(用户生成内容)包含了超过2亿条真实店铺评论、数百万家商户的详细POI信息以及用户行为数据,对商业分析、口碑监测、本地生活趋势研究具有不可替代的价值。然而,大众点评的安全团队投入了顶级资源构建反爬系统——从请求签名、行为验证到设备指纹,其防御强度甚至超过多数电商平台。本文将完整呈现一套2026年依然有效的技术方案,包括破解核心参数_token、动态代理池维护、无头浏览器指纹伪装等,最终产出一个生产级采集框架。目录。

2201_76125261的博客 816

[转载] Python的GIL是什么鬼,多线程性能究竟如何

原文:http://cenalulu.github.io/python/gil-in-python/ GIL是什么 首先需要明确的一点是GIL并不是Python的特性,它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言(语法)标准,但是可以用不同的编译器来编译成可执行代码。有名的编译器例如GCC,INTEL C++,Visual C++等...

weixin_30410999的博客 1210

直驱风机并网系统次同步振荡机理与振荡源定位方法研究

摘要: 本文针对直驱风机并网系统次同步振荡问题,研究了其产生机理与振荡源定位方法。通过建立系统小信号模型,采用特征值分析法揭示了次同步振荡的产生机制,并分析了电网强度、控制器参数对振荡特性的影响。基于暂态能量流理论,提出了通过计算各元件耗散能量来定位振荡源的方法。在MATLAB/Simulink平台搭建仿真系统验证了所提方法的有效性,为直驱风电场次同步振荡的分析与抑制提供了理论依据。 关键词:直驱风机;次同步振荡;小信号模型;暂态能量;振荡源定位

huanghm88的专栏 105

用 SAP-ABAP-1 把 ABAP 代码读懂:从 Generative AI Hub Orchestration 到 Joule 落地的实战指南

SAP-ABAP-1 是 SAP 推出的 ABAP 专用基础模型,专注于代码解释与理解。它能显著降低企业遗留系统的维护成本,帮助开发人员快速掌握复杂业务逻辑。该模型通过 SAP Generative AI hub 托管,支持 128,000 tokens 的上下文长度,适合分析大型 ABAP 类和 CDS 视图。典型应用场景包括代码解释、迁移辅助和云合规检查。调用需通过 Orchestration service 进行,确保企业级安全治理。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1217

分析运行中的 Python 程序

分析运行中的 Python 程序 背景 线上环境莫名其妙卡死 工具 py-spy 是一款开源的 Python 程序的抽样分析工具,使用 py-spy 可以很直观的查看 Python 程序的进程堆栈以及不同方法的耗时等,整个监控方式不需要对正在运行的程序做任何处理,即你不要修改程序代码也不需要重启程序。 py-spy 使用 Rust 语言开发,Rust 语言是一门号称 C/C++ 的运行速度、类 JavaScript 写法的语言,简单而言,就是开发效率高运行效率也高。py-spy 基于 Rust 语言提供的

no_name_left的博客 375

AI Agent智能体在Android开发中的应用

本文探讨了AIAgent(智能代理体)在Android开发中的应用,涵盖技术原理、实践案例与未来趋势。AIAgent通过机器学习、自然语言处理等技术实现代码生成、测试自动化及性能优化,显著提升开发效率。例如,强化学习模型可优化APP响应时间(公式:$\text{响应时间}=f(\text{负载},\text{资源})$),自动化测试覆盖率提升至95%。

郑伟强dev的专栏 126

Python 进阶:深入 GIL (上篇)

HackPython 致力于有趣有价值的编程教学简介熟悉 Python 的人理应都听过 GIL (Global Interpreter Lock,全局解...

weixin_30230009的博客 174

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Python 进阶:深入 GIL (下篇)

HackPython 致力于有趣有价值的编程教学简介有朋友吐槽,文章中太多表情,其实我加表情的初衷是避免大家阅读疲劳,既然造成了反效果,后面的内容就不会...

weixin_30230009的博客 410

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

python 3.9 gil_Python进阶:深入GIL(下篇)

Python进阶:深入GIL(下篇)HackPython致力于有趣有价值的编程教学简介有朋友吐槽,文章中太多表情,其实我加表情的初衷是避免大家阅读疲劳,既然造成了反效果,后面的内容就不会在添加表情了。在上一篇GIL的文章中,感性的了解了GIL,本篇文章尝试从源码层面来简单解析一下GIL,这里使用cpython 3.7版本的源码(其实这块没有太大的改变,所以你看3.5、3.6的Python源码都可以...

weixin_39974557的博客 334

python 多线程并行_Python进阶:深入GIL(上篇)

Python进阶:深入GIL(上篇)HackPython致力于有趣有价值的编程教学简介熟悉Python的人理应都听过GIL(Global Interpreter Lock,全局解释器锁) ,大概也知道它就是造成Python多线程并发其实是「伪并行」的核心原因,但依旧很多人没有深入其中,所以HackPython尝试以上、下两篇文章来阐释GIL,分别从其表现现象、对应源码以及Python对GIL改进等...

weixin_39585795的博客 201

python hack_Python进阶:深入GIL(上篇)

Python进阶:深入GIL(上篇)HackPython致力于有趣有价值的编程教学简介熟悉Python的人理应都听过GIL(Global Interpreter Lock,全局解释器锁) ,大概也知道它就是造成Python多线程并发其实是「伪并行」的核心原因,但依旧很多人没有深入其中,所以HackPython尝试以上、下两篇文章来阐释GIL,分别从其表现现象、对应源码以及Python对GIL改进等...

weixin_39908985的博客 81

Python 进阶:GIL 和 垃圾回收机制 深度剖析

Python进阶:GIL与垃圾回收机制 GIL(全局解释器锁) 现象:CPU密集型任务多线程可能更慢,因GIL限制“伪并行”。 原因:保护引用计数内存管理,适配非线程安全的C库。 机制:线程执行时锁定GIL,强制释放切换,不保障应用层线程安全。 解决方案:换解释器或用C/C++扩展。 垃圾回收机制 引用计数:对象引用为0时回收,但循环引用会导致泄漏。 循环引用处理:标记-清除算法识别垃圾,分代收集提升效率。 调试工具:objgraph可视化引用关系,辅助排查内存问题。 核心结论:GIL是CPython多线程

Balance 840

Python进阶:为什么GIL让多线程变得如此鸡肋?

阅读本文大约需要 9 分钟。做 Python 开发时,想必你肯定听过 GIL,它经常被 Python 程序员吐槽,说 Python 的多线程非常鸡肋,因为 GIL 的存在,Python 无法利用多线程提高性能。但事实真的如此吗?这篇文章,我们就来看一下 Python 的 GIL 到底是什么?以及它的存在,到底对我们的程序有哪些影响。GIL是什么?查阅官方文档,GIL 全称 Global Interpreter Lock,即全局解释器锁,它的官方解释如下:In CPython, the global inte

Python学习与数据挖掘 1001

python 多线程伪_Python进阶:深入GIL(上篇)

Python进阶:深入GIL(上篇)HackPython致力于有趣有价值的编程教学简介熟悉Python的人理应都听过GIL(Global Interpreter Lock,全局解释器锁) ,大概也知道它就是造成Python多线程并发其实是「伪并行」的核心原因,但依旧很多人没有深入其中,所以HackPython尝试以上、下两篇文章来阐释GIL,分别从其表现现象、对应源码以及Python对GIL改进等...

weixin_33994072的博客 127

cond. no python 计算_Python进阶:深入GIL(下篇)

Python进阶:深入GIL(下篇)HackPython致力于有趣有价值的编程教学简介有朋友吐槽,文章中太多表情,其实我加表情的初衷是避免大家阅读疲劳,既然造成了反效果,后面的内容就不会在添加表情了。在上一篇GIL的文章中,感性的了解了GIL,本篇文章尝试从源码层面来简单解析一下GIL,这里使用cpython 3.7版本的源码(其实这块没有太大的改变,所以你看3.5、3.6的Python源码都可以...

weixin_42098830的博客 281

Python进阶实战:从GIL、C扩展到网络编程的完整路线图

Python作为一门解释型语言,其进阶之路往往涉及对底层机制的深度理解。其中,GIL(全局解释器锁)是并发编程不可回避的核心概念,它决定了多线程与多进程的适用边界。而性能瓶颈的突破,则需要借助C扩展或Cython将热路径编译为原生代码,这也是许多高并发系统优化的关键手段。与此同时,装饰器、上下文管理等语言特性,为代码复用和资源管理提供了简洁抽象;基于asyncio与I/O多路复用的网络编程模型,则支撑着现代高并发服务的基石。版本迁移作为存量项目必须面对的挑战,又要求开发者具备兼容性意识与系统化工程方法。本文

weixin_30582943的博客 269

Python进阶:GIL(全局解释器锁)

一个不解之谜   一段代码 def CountDown(n): while n > 0: n -= 1 # CountDown(100000000) #==8秒 from threading import Thread n = 100000000 t1 = Thread(target=CountDown, args=[n // 2...

weixin_30629653的博客 147

《Python实战进阶》 No46:CPython的GIL与多线程优化

全局解释器锁(GIL)是CPython的核心机制,它保证了线程安全却限制了多核性能。本节通过**concurrent.futures**、**C扩展优化**和**多进程架构**,实战演示如何突破GIL限制,特别针对AI模型推理加速场景,提供可直接复用的性能优化方案。

yweng18的博客 835

Python面试进阶:从GIL、内存管理到元编程的硬核实战解析

在Python开发中,深入理解语言核心机制是构建高性能、可维护应用的基础。从内存管理原理出发,Python通过引用计数与分代垃圾回收机制自动管理对象生命周期,但开发者仍需警惕循环引用导致的内存泄漏风险。并发编程方面,全局解释器锁(GIL)是CPython的核心设计,它使得多线程在CPU密集型任务中无法并行,但在I/O密集型场景下,结合异步编程与多进程模型仍能有效提升吞吐量。元编程作为Python的动态特性代表,通过描述符、装饰器等机制,实现了对属性访问和函数行为的精细控制,是框架设计的基石。本文聚焦Pyth

weixin_34396902的博客 664

【Python 进阶之路】第8讲 | Python 内部机制:GIL、内存管理与元类编程

兄弟们,在之前的课程里,我们学会了怎么写 Python 代码,怎么优化性能,怎么做并发。但你有没有想过这些问题:这些问题,都涉及到 Python 的内部机制。理解这些机制,不仅能帮你写出更好的代码,还能让你在面试中脱颖而出。这一讲,咱们深入 Python 内部,揭开它的神秘面纱。环境声明:GIL(Global Interpreter Lock,全局解释器锁)是 Python 解释器(CPython)中的一把互斥锁,它确保同一时刻只有一个线程在执行 Python 字节码。为什么要有 GIL?Python 的内

帅哥 704
上一篇: Python进阶:使用ctypes将Python运行速度提升30倍
下一篇: 自由职业之路-从每小时5美元的Upwork工作到百万美元跨境咨询业务
二两hackpython
博客等级 码龄9年 13粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值