_thread — 低级线程 API ¶

此模块提供用于处理多个线程的低级原语 (也称 轻量进程 or tasks ) — 多个控制线程共享其全局数据空间。对于同步，简单的锁 (也称 mutexes or 二进制信号量 ) 被提供。 threading 模块提供构建于此模块之上，更易于使用且更高级的线程 API。

此模块定义以下常量和函数：

exception _thread. error ¶

引发特定线程错误。

3.3 版改变： 这现在是同义词内置 RuntimeError .

_thread. LockType ¶

这是锁对象的类型。

_thread. start_new_thread ( function , args [ , kwargs ] ) ¶

Start a new thread and return its identifier. The thread executes the function function with the argument list args (which must be a tuple). The optional kwargs argument specifies a dictionary of keyword arguments.

当函数返回时，线程默默退出。

When the function terminates with an unhandled exception, sys.unraisablehook() is called to handle the exception. The object attribute of the hook argument is function . By default, a stack trace is printed and then the thread exits (but other threads continue to run).

当函数引发 SystemExit 异常，它被默默忽略。

3.8 版改变： sys.unraisablehook() 现在用于处理未处理异常。

_thread. interrupt_main ( ) ¶

Simulate the effect of a signal.SIGINT signal arriving in the main thread. A thread can use this function to interrupt the main thread.

若 signal.SIGINT isn’t handled by Python (it was set to signal.SIG_DFL or signal.SIG_IGN ), this function does nothing.

_thread. exit ( ) ¶

引发 SystemExit exception. When not caught, this will cause the thread to exit silently.

_thread. allocate_lock ( ) ¶

Return a new lock object. Methods of locks are described below. The lock is initially unlocked.

_thread. get_ident ( ) ¶

Return the ‘thread identifier’ of the current thread. This is a nonzero integer. Its value has no direct meaning; it is intended as a magic cookie to be used e.g. to index a dictionary of thread-specific data. Thread identifiers may be recycled when a thread exits and another thread is created.

_thread. get_native_id ( ) ¶

Return the native integral Thread ID of the current thread assigned by the kernel. This is a non-negative integer. Its value may be used to uniquely identify this particular thread system-wide (until the thread terminates, after which the value may be recycled by the OS).

可用性 : Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, AIX.

3.8 版新增。

_thread. stack_size ( [ size ] ) ¶

Return the thread stack size used when creating new threads. The optional size argument specifies the stack size to be used for subsequently created threads, and must be 0 (use platform or configured default) or a positive integer value of at least 32,768 (32 KiB). If size is not specified, 0 is used. If changing the thread stack size is unsupported, a RuntimeError is raised. If the specified stack size is invalid, a ValueError is raised and the stack size is unmodified. 32 KiB is currently the minimum supported stack size value to guarantee sufficient stack space for the interpreter itself. Note that some platforms may have particular restrictions on values for the stack size, such as requiring a minimum stack size > 32 KiB or requiring allocation in multiples of the system memory page size - platform documentation should be referred to for more information (4 KiB pages are common; using multiples of 4096 for the stack size is the suggested approach in the absence of more specific information).

可用性 ：Windows、带有 POSIX 线程的系统。

_thread. TIMEOUT_MAX ¶

最大允许值为 timeout parameter of Lock.acquire() . Specifying a timeout greater than this value will raise an OverflowError .

3.2 版新增。

锁对象拥有下列方法：

lock. acquire ( waitflag=1 , timeout=-1 ) ¶

Without any optional argument, this method acquires the lock unconditionally, if necessary waiting until it is released by another thread (only one thread at a time can acquire a lock — that’s their reason for existence).

若整数 waitflag argument is present, the action depends on its value: if it is zero, the lock is only acquired if it can be acquired immediately without waiting, while if it is nonzero, the lock is acquired unconditionally as above.

若浮点 timeout argument is present and positive, it specifies the maximum wait time in seconds before returning. A negative timeout argument specifies an unbounded wait. You cannot specify a timeout if waitflag is zero.

返回值为 True 若成功获取锁， False 若不。

3.2 版改变： timeout 参数是新的。

3.2 版改变： 现在可以通过 POSIX 信号中断锁获得。

lock. release ( ) ¶

Releases the lock. The lock must have been acquired earlier, but not necessarily by the same thread.

lock. locked ( ) ¶

返回锁的状态： True if it has been acquired by some thread, False 若不。

In addition to these methods, lock objects can also be used via the with 语句，如：

import _thread
a_lock = _thread.allocate_lock()
with a_lock:
    print("a_lock is locked while this executes")
							

告诫：

• Threads interact strangely with interrupts: the KeyboardInterrupt exception will be received by an arbitrary thread. (When the signal module is available, interrupts always go to the main thread.)

• 调用 sys.exit() 或引发 SystemExit 异常相当于调用 _thread.exit() .

• It is not possible to interrupt the acquire() method on a lock — the KeyboardInterrupt exception will happen after the lock has been acquired.

• When the main thread exits, it is system defined whether the other threads survive. On most systems, they are killed without executing try … finally clauses or executing object destructors.

• When the main thread exits, it does not do any of its usual cleanup (except that try … finally clauses are honored), and the standard I/O files are not flushed.

上一话题

contextvars — 上下文变量

下一话题

网络和进程间通信