gil | 易学教程

Python GIL prevent CPU usage to exceed 100% in multiple core machine?

阅读更多关于 Python GIL prevent CPU usage to exceed 100% in multiple core machine?

问题 Many references say that, Python GIL lower down the performance of multi threading code in multi core machine, since each thread will need to acquire the GIL before executioin. In other words, it looks like GIL make a multi threading Python program to a single thread mode in fact. For example: (1) Thread A get GIL, execute some time, release GIL (2) Thread B get GIL, execute some time, release GIL ... However, after some simple experiments, I found that although GIL lower down the performance

How to call a multi-threaded C function in Cython?

阅读更多关于 How to call a multi-threaded C function in Cython?

问题 I have a question about how to call a multi-threaded C function in Cython. Do I need to release/acquire the GIL before/after I do the multi-threaded stuff in the C function? Or can I just use it like a normal C function? Should I follow the directions here for general Python extensions? 回答1: You should have looked down a few sections. http://docs.python.org/c-api/init.html#non-python-created-threads 来源： https://stackoverflow.com/questions/11687960/how-to-call-a-multi-threaded-c-function-in

f2py function release GIL

阅读更多关于 f2py function release GIL

问题 Does the Global Interpretter Lock (GIL) get released when I call an f2py wrapped function? (I'm happy to try to discover on my own, but I'm not familiar enough with the numpy source to know where to start looking)... To clarify, a good answer to this question would either help me to know where in the numpy source to look for a Py_BEGIN_ALLOW_THREADS or it would simply let me know if the GIL is released (preferably with some evidence). 回答1: No, f2py defaults to leaving the GIL in place.

python 全局解释锁GIL

阅读更多关于 python 全局解释锁GIL

Python的全局解释器锁GIL用于保护python解释器，使得任意时刻，只有一个线程在解释器中运行。从而保证线程安全在多线程环境中，Python 虚拟机按以下方式执行： 1. 设置GIL 2. 切换到一个线程去运行 3. 运行： a. 指定数量的字节码指令，或者 b. 线程主动让出控制（可以调用time.sleep(0)） 4. 把线程设置为睡眠状态 5. 解锁GIL 6. 再次重复以上所有步骤由上可知，至少有两种情况python会解锁GIL，做线程切换：一是一但有IO操作时；线程连续执行了一定数量的指令时；当然此处的线程切换不一定就一定会切换到其他线程执行，因为如果当前线程优先级比较高的话，可能在让出锁以后，又继续获得锁，并优先执行。由此可以看到，Python多线程是单cpu意义上的多线程，它和多cpu上的多线程有着本质的区别。GIL会影响到那些严重依赖CPU的程序（比如计算型的），即使Python的多线程程序并不能利用多核CPU的优势；但是如果程序大部分只会设计到I/O，比如网络交互，那么使用多线程就很合适，因为它们大部分时间都在等待。来源： https://www.cnblogs.com/yoyo008/p/9366088.html

400 threads in 20 processes outperform 400 threads in 4 processes while performing a CPU-bound task on 4 CPUs

阅读更多关于 400 threads in 20 processes outperform 400 threads in 4 processes while performing a CPU-bound task on 4 CPUs

问题 This question is very similar to 400 threads in 20 processes outperform 400 threads in 4 processes while performing an I/O-bound task. The only difference is that the linked question is about an I/O-bound task whereas this question is about a CPU-bound task. Experimental Code Here is the experimental code that can launch a specified number of worker processes and then launch a specified number of worker threads within each process and perform the task of computing the n-th prime number.

Profiling the GIL

阅读更多关于 Profiling the GIL

问题 Is there a way to profile a python process' usage of the GIL ? Basically, I want to find out what percentage of the time the GIL is held . The process is single-threaded. My motivation is that I have some code written in Cython, which uses nogil . Ideally, I would like to run it in a multi-threaded process, but in order to know if that can potentially be a good idea, I need to know if the GIL is free a significant amount of the time. I found this related question, from 8 years ago. The sole

Why Python is not better in multiprocessing or multithreading applications than Java?

阅读更多关于 Why Python is not better in multiprocessing or multithreading applications than Java?

问题 Since Python has some issues with GIL, Java is better for developing multiprocessing applications. Could you please justify the exact reasoning of java's effective processing than python in your way? 回答1: The biggest problem in multithreading in CPython is the Global Interpreter Lock (GIL) (note that other Python implementations don't necessarily share this problem!) The GIL is an implementation detail that effectively prevents parallel (simultaneous) execution of separate threads in Python.

Is the Python GIL really per interpreter?

阅读更多关于 Is the Python GIL really per interpreter?

问题 I often see people talking that the GIL is per Python Interpreter (even here on stackoverflow). But what I see in the source code it seems to be that the GIL is a global variable and therefore there is one GIL for all Interpreters in each python process. I know they did this because there is no interpreter object passed around like lua or TCL does, it was just not designed well in the beginning. And thread local storage seems to be not portable for the python guys to use. Is this correct? I

Where can I find a list of numpy functions which release the GIL?

阅读更多关于 Where can I find a list of numpy functions which release the GIL?

问题 I have found several SO questions asking about this in one way or another, but none of them actually either give a list or refer to one. This question refers to a wiki page, but while the wiki page talks about the GIL and multi-threading, it doesn't give a list of GIL releasing functions. This mailing list post indicates that the only way to find out is to read the numpy source. Really? 回答1: It's not guaranteed to catch everything, but I just ran: git grep nogil in my clone of the numpy

GIL in Python 3.1

阅读更多关于 GIL in Python 3.1

问题 Does anybody knows fate of Global Interpreter Lock in Python 3.1 against C++ multithreading integration 回答1: GIL is still there in CPython 3.1; the Unladen Swallow projects aims (among many other performance boosts) to eventually remove it, but it's still a way from its goals, and is working on 2.6 first with the intent of eventually porting to 3.x for whatever x will be current by the time the 2.y version is considered to be done. For now, multiprocessing (instead of threading) remains the