标签: gil

我知道Python有一个GIL，它使得线程不能同时运行，因此线程只是上下文切换。

为什么java不一样？每种语言的同一 CPU 上的线程不能并行运行。

1. 在java中创建新线程是否利用多核机器中的核心？

2. 与 java 相比，python 只能在同一 CPU 上生成线程？

3. 如果 1. 是这种情况，当使用比 CPU 更多的线程时，即使在 java 中，也会再次返回其中几个线程的上下文切换？

4. 如果 1. 是这样的话，那么它与多处理有何不同？因为不能保证利用多个核心？

5. 线程的全部意义不就是能够使用相同的内存空间吗？如果java确实在多个线程中运行其中一些以实现并行性，那么它们如何真正共享内存？

谢谢

PyNaCI会释放全局解释器锁吗？使用 PyNaCI 的多线程加密是否适合SecretBox？

我想使用 PyNaCl 加密相对大量的数据（~500 MB）。为此，我将其分成大约 5MB 的块并使用ThreadPoolExecutor(). 这是理想的吗？我不知道 PyNaCl 是否发布了 Python 的 GIL，也不知道它是否会真正并行加密块，从而提高性能。

编辑：为了避免混淆，让我澄清一下实验结果。在对当前的实现进行了多次测试之后，我发现它比直接加密整个数据要快一些，并且比简单的for循环要快得多。然而，我需要确凿的证据（参考文档，或者某种测试）来证明任务确实是并行运行的并且GIL不会阻塞性能。

这是我当前使用的实现ThreadPoolExecutor()

from concurrent.futures import ThreadPoolExecutor
from os import urandom
from typing import Tuple

from nacl import secret
from nacl.bindings import sodium_increment
from nacl.secret import SecretBox


def encrypt_chunk(args: Tuple[bytes, SecretBox, bytes, int]):
    chunk, box, nonce, macsize = args
    try:
        outchunk = box.encrypt(chunk, nonce).ciphertext
    except Exception as e:
        err = Exception("Error encrypting chunk")
        err.__cause__ = e
        return …

我在新的GIL上阅读这个页面找到/可以在Python 3.2中找到它,我想知道它是否是"杀手级功能"将触发从Python 2.x到3.x的转换.

你们有什么感想？

我的问题当然是GIL.在我分析数据时,最好在两者之间展示一些情节(所以等待结果并不是太无聊)

但GIL阻止了这一点(这让我开始问自己,Python本来就是一个好主意).

我只能显示情节,等到用户关闭它并在此之后开始计算.显然浪费时间.

我已经尝试过子进程和多处理模块,但似乎无法让它们工作.

对这个有什么想法吗？谢谢

编辑:好的,所以它不是GIL而是show().

是否有可能从python代码获取全局解释器锁？或者这纯粹是在C方面实现的？

在我的小小理解中,multi-threading在大多数情况下驱动编程的性能因素并非全部.(不论Java或Python).

我读这启发性的文章上GIL的SO.文章总结了python采用的GIL机制; 即只有一个single Thread可以python byte code在任何给定时间执行.这使得single thread应用程序真的更快.

我的问题如下:

因为如果Thread在给定点只提供一个,是否multiprocessing或thread模块提供了克服GIL强加的限制的方法？如果没有,它们为实际multi-task工作提供了哪些功能

在接受的答案中,上述帖子的评论部分提出了一个问题,但没有回答？我脑子里也有这个问题

^so at any time point of time, only one thread will be serving content to client... 
so no point of actually using multithreading to improve performance. right?

我现在正在使用Python实现数据订阅者,订阅数据发布者(实际上是ZeroMQ发布者套接字),并在收到任何新消息后收到通知.在我的订户中,消息在收到后被转储到数据处理器.订户完成后也会收到订户的通知.由于数据处理器是用C++编写的,因此我必须使用简单的C++模块扩展Python代码.

下面是我的数据订阅者的简化的可运行代码示例.代码main.py,其中模块proc代表处理器,订阅ZeroMQ套接字localhost:10000,设置回调,并通过调用将接收的消息发送到处理器proc.onMsg.

#!/bin/python
# main.py

import gevent
import logging
import zmq.green as zmq

import pub 
import proc

logging.basicConfig( format='[%(levelname)s] %(message)s', level=logging.DEBUG )

SUB_ADDR = 'tcp://localhost:10000'

def setupMqAndReceive():
    '''Setup the message queue and receive messages.
    '''
    ctx  = zmq.Context()
    sock = ctx.socket( zmq.SUB )
    # add topics
    sock.setsockopt_string( zmq.SUBSCRIBE, 'Hello' )

    sock.connect( SUB_ADDR )

    while True:
        msg = sock.recv().decode( 'utf-8' )
        proc.onMsg( msg )

def callback( a, b ):
    print( '[callback]',  a, b ) 

def …

from concurrent.futures import ThreadPoolExecutor, as_completed

def main():
    with ThreadPoolExecutor(max_workers=16) as producersPool:
        for i in [1,2,3,4,5,6,7,8,9,0]:
            producersPool.submit((lambda i : print(i))(i))


if __name__ == "__main__":
    main()

使用python3运行:

1
2
3
4
5
6
7
8
9
0

总是一样.

现在我希望你让我正确 - 我不一定希望重新安排这些任务,但我只是想知道为什么排序会发生？我的意思是,人们可以期望在一个线程内以确定的方式完成任务,但线程的严格排队对我来说似乎有些奇怪.

无论如何,我如何在Python 3中获得真正的并发？(据我所知,Jython和IronPython只支持2.x).

我有一些我想使用 Cython 并行执行的独立计算。

现在我正在使用这种方法：

import numpy as np
cimport numpy as cnp
from cython.parallel import prange

[...]

cdef cnp.ndarray[cnp.float64_t, ndim=2] temporary_variable = \
    np.zeros((INPUT_SIZE, RESULT_SIZE), np.float64)
cdef cnp.ndarray[cnp.float64_t, ndim=2] result = \
    np.zeros((INPUT_SIZE, RESULT_SIZE), np.float64)

for i in prange(INPUT_SIZE, nogil=True):
    for j in range(RESULT_SIZE):
        [...]
        temporary_variable[i, j] = some_very_heavy_mathematics(my_input_array)
        result[i, j] = some_more_maths(temporary_variable[i, j])

这种方法有效，但我的问题来自事实上我需要几个temporary_variables。这会在增长时导致大量内存使用INPUT_SIZE。但我相信真正需要的是每个线程中的临时变量。

我是否面临 Cython 的恶作剧的限制，我是否需要学习正确的 C 语言，或者我是否在做/理解一些非常错误的事情？

编辑：我一直在寻找的功能都openmp.omp_get_max_threads()和openmp.omp_get_thread_num()创建合理大小的临时数组。我必须cimport openmp先。

Ruby 3.0 版本引入了 Ractor 以及它们在示例中的表示方式，让人想起了 Python 的 MultiProcessing 模块。

所以...

1. Ruby 的 Ractor 是否只是伪装的多个进程，而 GIL 仍然统治着线程？

2. 如果不是，您能否提供一个示例，其中 Ractor 在速度和通信延迟方面都比多处理更具优势？

3. Ractor 能否像 C/C++ 线程一样快且延迟低？

谢谢

假设我有这个示例代码:

x = foo1(something1)
y = foo2(something2)

z = max(x, y)

我想通过使用线程来改善此代码的执行时间(希望它有帮助不是吗？).我想让事情尽可能简单,所以基本上我想做的是创建两个同时工作的线程,分别计算foo1和foo2.

我正在阅读有关线程的内容,但我发现它有点棘手,我不能因为做这么简单的事情而浪费太多时间.

假设我在多核 CPU（比如 4）上运行多个 python 进程（不是线程）。GIL 是流程级别，因此特定流程中的 GIL 不会影响其他流程。

我的问题是，一个进程中的 GIL 是只占用 4 个内核中的一个内核，还是会占用所有 4 个内核？

如果一个进程同时锁定所有内核，那么多处理应该不会比 Python 中的多线程更好。如果不是，如何将内核分配给各种进程？

作为观察，在我的 8 核系统中（由于超线程是 4*2），当我运行单个 CPU 绑定进程时，8 个核中有 4 个的 CPU 使用率上升。

简化这个：

在 4 核 CPU 上运行的 4 个 python 线程（在一个进程中）将比执行相同工作的单线程花费更多时间（考虑到工作完全受 CPU 限制）。4 个不同的进程做这么多的工作会减少近 4 倍的时间吗？

在 CPython 环境中，一个线程不会从另一个线程获取 GIL，除非它被阻塞（比如 using sleep()）或在 IO 上

在下面的服务器代码中，

# server.py
import socket
import sys
from threading import Thread

def echoHandler(conn, addr):
    try:
        while True:
            data = conn.recv(16) # Blocking call
            if data:
                print(data.decode('utf-8'))
                conn.sendall(data)
            else:
                break
    finally:
        print('Closing the connection from server')
        conn.close()

if __name__ == '__main__':
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_address = ('localhost', 10006)
    sock.bind(server_address)
    sock.listen(1)
    while True:
        conn, addr = sock.accept()
        t = Thread(target=echoHandler, args=(conn, addr))
        t.daemon = True
        t. start()
        print('Waiting for another conn')

#client.py …