我正在运行一个多线程 python 脚本。它的作用是抓取网络并将其插入/更新到 mysql 中。这是我的代码
mythread.py
import threading
import time
class MyThread (threading.Thread):
def __init__(self, threadID, threadname, q):
threading.Thread.__init__(self)
self.threadID = threadID
self.threadname = threadname
self.queue = q
self.__exitFlag = False
self.__signal_lock = threading.Lock()
def run(self):
print "Starting " + self.threadname
self.process_data()
print "Exiting " + self.threadname
def stop(self):
with self.__signal_lock:
self.__exitFlag = True
def process_data(self):
while not self.__exitFlag:
if not self.queue.empty():
data = self.queue.get()
# crawl data from the web...
# update to mysql
# assuming we have already …Run Code Online (Sandbox Code Playgroud) 我想将单个线程的日志获取到仅包含该线程的日志的特定文件中。
在大多数情况下,将所有线程记录到单个文件中是完全令人满意的。这对我不起作用。我正在将并发模型应用到一个大型且当前迭代的代码库,该代码库在不同的模块中到处实现了日志记录,并且我试图更改尽可能少的代码。
我可以想到几个看起来有点hacky的解决方案,涉及检测当前代码是否在线程中执行,所以我想知道是否有一个很好的Pythonic方法来做到这一点。
我用Python编写了一个程序,它使用多线程,我想知道在计时和所有统计数据下执行了多少个线程,有没有办法使用调试器来获得这些结果?
PS:我正在使用 PyCharm。
我对 python 世界还很陌生,不幸的是我还找不到任何解决方案。
我在 Mac OS X 10.13.2 上运行 python 3.6 和 matplotlib==1.3.1
目前我正在尝试构建一个小型软件,它以 4Hz 的频率获取数据,并以 1Hz 的频率在绘图中显示获取的数据。因此,我创建了一个在线程中运行的类来获取数据,并创建了另一个类来更新实际的绘图。中间有一个数据类,它将保存数据并用作两个类之间的接口。
import matplotlib.pyplot as plt
import numpy as np
import threading
import random
import time
class MyDataClass():
def __init__(self):
self.XData = [0]
self.YData = [0]
class MyPlotClass(threading.Thread):
def __init__(self, dataClass):
threading.Thread.__init__(self)
self._dataClass = dataClass
self._period = 1
self._nextCall = time.time()
self.hLine, = plt.plot(0, 0)
plt.ion()
def run(self):
while True:
self.hLine.set_data(self._dataClass.XData, self._dataClass.YData)
plt.draw()
print("updated %i datapoints" % len(self._dataClass.XData))
# sleep until next execution
self._nextCall …Run Code Online (Sandbox Code Playgroud) python macos multithreading matplotlib python-multithreading
我正在尝试理解Python 中的守护线程。我的理解是,一旦主线程退出或非守护线程被杀死,守护线程就会自动被杀死。然而,在 Windows 机器上,这不是我的观察结果。
import threading
import time
def print_work_a():
print('Starting of thread :', threading.currentThread().name)
time.sleep(2)
print('Finishing of thread :', threading.currentThread().name)
def print_work_b():
print('Starting of thread :', threading.currentThread().name)
print('Finishing of thread :', threading.currentThread().name)
a = threading.Thread(target=print_work_a, name='Thread-a', daemon=True)
b = threading.Thread(target=print_work_b, name='Thread-b')
a.start()
b.start()
Run Code Online (Sandbox Code Playgroud)
观察到的输出:
>>> Starting of thread :Thread-a
Starting of thread :Thread-b
Finishing of thread :Thread-b
Finishing of thread :Thread-a
Run Code Online (Sandbox Code Playgroud)
我预计输出不会包含Finishing of thread :Thread-a因为到那时非守护线程将被杀死,因此守护线程也将被杀死。导致守护线程保持活动状态的代码中的错误是什么?
def feedforward(self,d):
out = []
for neuron in self.layer:
out.append(neuron.feedforward(d))
return np.array(out)
Run Code Online (Sandbox Code Playgroud)
这是我为执行前馈而编写的原始代码。我想使用多线程提高执行速度,因此我编辑了要从模块ThreadPoolExecutor中使用的代码concurrent.futures
def parallel_feedforward(self,func,param):
return func.feedforward(param)
def feedforward(self,d):
out = []
with ThreadPoolExecutor(max_workers = 4) as executor:
new_d = np.tile(d,(len(self.layer),1))
for o in executor.map(self.parallel_feedforward,self.layer,new_d):
out.append(o)
return np.array(out)
Run Code Online (Sandbox Code Playgroud)
变量d是一个向量,我使用np.tile()它以便executor.map正确地获取输入
计时两者的执行速度后。我发现 Code 1 明显比 Code 2 快(Code 2 几乎慢了 8-10 倍)。但是使用多线程的代码不会比循环的代码更快吗?是因为我写的代码错误还是因为其他原因。如果是因为我的代码中有一些错误,有人可以告诉我我做错了什么吗?
提前感谢您的帮助。
我的目标是创建一个可用于测量另一个函数的执行和资源使用情况的函数。通过教程,我使用 Python 的 ThreadPoolExecutor 创建了以下内容:
from resource import *
from time import sleep
from concurrent.futures import ThreadPoolExecutor
class MemoryMonitor:
def __init__(self):
self.keep_measuring = True
def measure_usage(self):
max_usage = 0
u_run_time = 0
s_run_time = 0
while self.keep_measuring:
max_usage = max(max_usage, getrusage(RUSAGE_SELF).ru_maxrss)
u_run_time = max(u_run_time, getrusage(RUSAGE_SELF).ru_utime)
s_run_time = max(s_run_time, getrusage(RUSAGE_SELF).ru_stime)
sleep(0.1) # run this loop every 0.1 seconds
return [max_usage, u_run_time, s_run_time]
def execute(function):
with ThreadPoolExecutor() as executor:
monitor = MemoryMonitor()
stats_thread = executor.submit(monitor.measure_usage)
try:
fn_thread = executor.submit(function)
result = fn_thread.result() …Run Code Online (Sandbox Code Playgroud) python encapsulation python-multithreading python-3.x concurrent.futures
我有一个包含 1 个进程的程序,它启动了很多线程。每个线程可能使用 subprocess.Popen 来运行一些命令。我看到运行命令的时间随着线程数的增加而增加。例子:
>>> def foo():
... s = time.time()
... subprocess.Popen('ip link show'.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True).communicate()
... print(time.time() - s)
...
>>> foo()
0.028950929641723633
>>> [threading.Thread(target=foo).start() for _ in range(10)]
0.058995723724365234
0.07323050498962402
0.09158825874328613
0.11541390419006348 # !!!
0.08147192001342773
0.05238771438598633
0.0950784683227539
0.10175108909606934 # !!!
0.09703755378723145
0.06497764587402344
Run Code Online (Sandbox Code Playgroud)
是否有另一种方法可以在不降低性能的情况下从单个进程并行执行大量命令?
我是多重处理的新手,如果有人可以在这里指导/帮助我,我将非常感激。我有以下 for 循环,它从两个函数获取一些数据。代码看起来像这样
for a in accounts:
dl_users[a['Email']] = get_dl_users(a['Email'], adConn)
group_users[a['Email']] = get_group_users(a['Id'], adConn)
print(f"Users part of DL - {dl_users}")
print(f"Users part of groups - {group_users}")
adConn.unbind()
Run Code Online (Sandbox Code Playgroud)
这工作正常并获得所有结果,但最近我注意到它需要很多时间来获取用户列表,即 dl_users 和 group_users。大约需要 14-15 分钟才能完成。我正在寻找可以加速该函数的方法,并希望将此 for 循环转换为多处理。get_group_users并get_dl_users调用 LDAP,所以我不能 100% 确定是否应该将其转换为多处理或多线程。任何建议都会有很大帮助
python python-multithreading python-3.x python-multiprocessing
多线程正在打印输出,但不是多处理。搜索堆栈溢出并回答问题并没有解决问题。
多重处理不起作用。
from threading import Thread
import datetime
from multiprocessing import Process
import sys
import time
def func1():
print('Working')
time.sleep(5)
global a
a=10
print(datetime.datetime.now())
def func2():
print("Working")
time.sleep(10)
print(datetime.datetime.now())
p1 = Process(target=func1)
p1.start()
p2 = Process(target=func2)
p2.start()
p1.join()
p2.join()
print(a)
Run Code Online (Sandbox Code Playgroud)
即使 print(a) 也没有打印该值。它说
NameError: name 'a' is not defined
Run Code Online (Sandbox Code Playgroud) python multiprocessing python-multithreading python-multiprocessing