标签: python-multithreading

我正在编写一个物理模拟程序，发现after()非常有用。

我曾经想为物理计算和仿真创建一个线程。但是，当我最终注意到该功能时，我改用了它。

因此，我对Tkinter如何实现该功能感到好奇。是多线程的吗？

我需要能够将 control-c 发送到我启动的新线程。我该怎么办。我可以启动线程，但我需要像在命令行中使用 control-c 那样停止。

from Tkinter import *
import threading # should use the threading module instead!
import Queue
import os


def show1():
    os.system('ola_recorder -p MyRecord -i 0')

def show2 ():
    os.system('ola_recorder -p MyRecord ')

def stop ():
    os.system('^c')


t = threading.Thread(name='Show2', target=show2)

root = Tk()
b = Button(root, text="Show 1", command=lambda: thread.start_new(show1, ()))
b.pack()

b2 = Button(root, text="Show 2", command=lambda: t.start())
b2.pack()

root.mainloop()

我以前从未使用过多处理模块。

有没有办法将 for 循环变成并发子进程。喜欢

for i in xrange(10): list.append(i)

而不是顺序，让它并行？

我尝试使用队列模块

q = Queue.Queue()

for i in xrange(10):
    q.put(i)


def addto(q):
    new.append(q.get(block=False))


processes = [Process(target=addto, args=(q,))]
for p in processes:
    p.start()
for p in processes:
    p.join()

它给出了一个很长的错误，我粘贴了最后一个：

C:\WinPython-64bit-2.7.3.3\python-2.7.3.amd64\lib\pickle.pyc in save_global(self, obj, name, pack)
    746             raise PicklingError(
    747                 "Can't pickle %r: it's not found as %s.%s" %
--> 748                 (obj, module, name))
    749         else:
    750             if klass is not obj:

PicklingError: Can't pickle <type 'thread.lock'>: it's not found as thread.lock

我也经常看到这个： …

我有一个threading.Lock对象,我想知道是否current_thread持有这个锁.实现这一目标的最简单方法是什么？

我有以下代码：

class MyThread(Thread):
    def __init__(self, command, template, env, build_flavor, logger):
        Thread.__init__(self)
        self.command = command
        self.template = template
        self.env = env
        self.build_flavor = build_flavor
        self.logger = logger

    def run(self):
        self.logger.info('Running (%s)...this may take several minutes. Please be patient' % self.build_flavor)
        run_command(self.command, self.template, self.env)
        self.logger.info('Complete (%s)' % self.build_flavor)
        return

然后在另一个类中，当我创建实际线程时：

if self.build_type == 'default':
            threads = []
            for t in self.template:
                modify_template(t)
                build_flavor = self.getmatch(t)
                thread = MyThread(packer, t, self.new_env, build_flavor, self.logger)
                thread.setName(build_flavor)
                thread.start()
                threads.append(thread)
            for thread in threads:
                thread.join()
            vmware_create()
            openstack_create() …

我在windows中编写了这段代码,但是当我将它复制到我的raspberry pi(运行Jessie Debian)时,它会给出运行时错误

我的代码:

from Tkinter import *
from PIL import ImageTk,Image
from time import sleep
import thread
root = Tk()
img=ImageTk.PhotoImage(Image.open("1.jpg").resize((root.winfo_screenwidth()-3,root.winfo_screenheight()-3)))
panel = Label(root, image = img)
panel.pack(side = "bottom", fill = "both", expand = "yes")
if __name__ == '__main__':
    thread.start_new_thread(root.mainloop,())
    for i in xrange(1,5):
        sleep(1)
        img2 = ImageTk.PhotoImage(Image.open(str(i)+".jpg").resize((root.winfo_screenwidth()-3,root.winfo_screenheight()-3)))
        panel.configure(image = img2)
        panel.image = img2

在linux中执行时会出错:

Unhandled exception in thread started by <bound method Tk.mainloop of <Tkinter.Tk instance at 0x75b605d0>>
Traceback (most recent call last):
  File "/usr/lib/python2.7/lib-tk/Tkinter.py", line 1124, …

我有一个布尔值，我想将它传递给正在执行来自不同模块的方法的不同线程。此布尔值充当取消标记，因此如果设置，线程应退出。它似乎是按值传递的，因为如果我在另一个线程中设置它，它在其他线程中不会改变。谢谢。

import module2
from threading import Thread

cancellationToken = False

def main:
    thread2 = Thread(target = module2.method2, args (on_input, cancellationToken, ))
    thread2.start()
    ...
    thread2.join()

def on_input(command):
    global cancellationToken
    ...
    if(...):
        cancellationToken = True
    ...

module2 中的 method2 只是一个简单的无限 while 循环，它检查取消标记并响应用户输入。

def method2(on_input, cancellationToken):
    while(True):
        if(cancellationToken):
            return
        ...
        on_input(...)

我试图ThreadPoolExecutor在Windows 7上的Python 3.6中使用，似乎异常被忽略或停止了程序执行。示例代码：

#!/usr/bin/env python3

from time import sleep

from concurrent.futures import ThreadPoolExecutor

EXECUTOR = ThreadPoolExecutor(2)


def run_jobs():
    EXECUTOR.submit(some_long_task1)
    EXECUTOR.submit(some_long_task2, 'hello', 123)
    return 'Two jobs was launched in background!'


def some_long_task1():
    print("Task #1 started!")
    for i in range(10000000):
        j = i + 1
    1/0
    print("Task #1 is done!")


def some_long_task2(arg1, arg2):
    print("Task #2 started with args: %s %s!" % (arg1, arg2))
    for i in range(10000000):
        j = i + 1
    print("Task #2 is done!")


if __name__ == '__main__': …

我在ARM Raspbian linux,Python 2.7.13和amd64 Gentoo linux,Python 2.7.14上运行代码

我有一个功能

import threading
def r() : 
    s = 1
    while True:
        s = s + 1

然后我为这个函数创建线程

t = threading.Thread(target=r)
t.start()

然后在htop中我可以看到另一个生成的进程(有自己的PID)!和处理.线程文档说:

CPython实现细节:在CPython中,由于Global Interpreter Lock,只有一个线程可以同时执行Python代码(即使某些面向性能的库可能会克服此限制).如果您希望应用程序更好地利用计算资源对于多核机器,建议您使用多处理.

为什么这种行为与文档不同？

我正在尝试在Python中运行代码并行.

我的用例如下:我有一个需要运行数千次的进程.但由于它依赖于下载,我需要小心我同时运行多少(每分钟我的请求数量有限).因此,我希望始终同时运行该功能10次,每次完成一次我想启动一个新的过程.

在快速阅读之后,线程模块似乎正是我正在寻找的.但是,一些小实验似乎表明Python不会在并行中运行线程.

当我运行以下代码时

import threading
import time

wait = 0.4

def f(x):
 for j in range(1,100):
    time.sleep(wait)
    print(x)


threading.Thread(target = f(1)).start()
threading.Thread(target = f(2)).start()

我进入了命令行

1
1
1
1
1

不会显示单个2,直到所有100个都打印出来.

这是怎么来的？理论上f(1)和f(2)应该同时运行吗？