Hướng dẫn how do you call a class using thread in python? - làm cách nào để bạn gọi một lớp bằng luồng trong python?
I don't know how to call a method in a class, especially if it has initialization parameters, but you can try this method。 I'm trying to use multiple processes to solve this problem, right。 Show Multithreading - Subclassing Thread bogotobogo.com site search: Python MultithreadCreating a thread and passing arguments to the thread run() methods So far, we've been using a thread by instantiating the Thread class given by the package (threading.py). To create our own thread in Python, we'll want to make our class to work as a thread. For this, we should subclass our class from the Thread class. First thing we need to do is to import Thread using the following code: from threading import Thread Then, we should subclass our class from the Thread class like this: class MyThread(Thread): Just for reference, here is a code snippet from the package for the Thread class: class Thread: ... def start(self): """Start the thread's activity. It must be called at most once per thread object. It arranges for the object's run() method to be invoked in a separate thread of control. This method will raise a RuntimeError if called more than once on the same thread object. """ if not self._initialized: raise RuntimeError("thread.__init__() not called") if self._started.is_set(): raise RuntimeError("threads can only be started once") with _active_limbo_lock: _limbo[self] = self try: _start_new_thread(self._bootstrap, ()) except Exception: with _active_limbo_lock: del _limbo[self] raise self._started.wait() def _bootstrap(self): try: self._bootstrap_inner() except: if self._daemonic and _sys is None: return raise def _bootstrap_inner(self): try: ... try: self.run() except SystemExit: pass except: def run(self): try: if self._target: self._target(*self._args, **self._kwargs) finally: # Avoid a refcycle if the thread is running a function with # an argument that has a member that points to the thread. del self._target, self._args, self._kwargs As a Thread starts up, it does some basic initialization and then calls its run() method, which calls the target function passed to the constructor. The Thread class represents an activity that runs in a separate thread of control. There are two ways to specify the activity:
No other methods (except for the constructor) should be overridden in a subclass. In other words, we only override the __init__() and run() methods of a class. In this section, we will create a subclass of Thread and override run() to do whatever is necessary: import threading class MyThread(threading.Thread): def run(self): pass if __name__ == '__main__': for i in range(3): t = MyThread() t.start() Once a thread object is created, its activity must be started by calling the thread's start() method. This invokes the run() method in a separate thread of control. Once the thread's activity is started, the thread is considered 'alive'. It stops being alive when its run() method terminates - either normally, or by raising an unhandled exception. The is_alive() method tests whether the thread is alive. import threading
import time
class MyThread(threading.Thread):
def run(self):
time.sleep(5)
return
if __name__ == '__main__':
for i in range(3):
t = MyThread()
t.start()
print 't.is_alive()=', t.is_alive()
t.join()
print 't.is_alive()=', t.is_alive()
Output: t.is_alive()= True t.is_alive()= False t.is_alive()= True t.is_alive()= False t.is_alive()= True t.is_alive()= False As we can see from the output, each of the three thread is alive just after the start but t.is_alive()=False after terminated. Before we move forward, for our convenience, let's put a logging feature into a place: import threading
import time
import logging
logging.basicConfig(level=logging.DEBUG,
format='(%(threadName)-9s) %(message)s',)
class MyThread(threading.Thread):
def run(self):
logging.debug('running')
return
if __name__ == '__main__':
for i in range(3):
t = MyThread()
t.start()
Output: (Thread-1 ) running (Thread-2 ) running (Thread-3 ) running Passing args to the customized thread Because the *args and **kwargs values passed to the Thread constructor are saved in private variables, they are not easily accessed from a subclass. To pass arguments to a custom thread type, we need to redefine the constructor to save the values in an instance attribute that can be seen in the subclass: import threading
import time
import logging
logging.basicConfig(level=logging.DEBUG,
format='(%(threadName)-9s) %(message)s',)
class MyThread(threading.Thread):
def __init__(self, group=None, target=None, name=None,
args=(), kwargs=None, verbose=None):
super(MyThread,self).__init__(group=group, target=target,
name=name, verbose=verbose)
self.args = args
self.kwargs = kwargs
return
def run(self):
logging.debug('running with %s and %s', self.args, self.kwargs)
return
if __name__ == '__main__':
for i in range(3):
t = MyThread(args=(i,), kwargs={'a':1, 'b':2})
t.start()
Output: from threading import Thread0 We overrided the __init__() using: from threading import Thread1 For Python 3, we could have used without any args within the super(), like this: from threading import Thread2 Python MultithreadCreating a thread and passing arguments to the thread Python tutorialPython Home Các phương pháp của lớp chủ đề trong Python là gì?Phương pháp của lớp chủ đề trong Python.. active_count(). enumerate(). isAlive(). join(). join(seconds). Phương thức nào được thực thi khi phương thức start () của đối tượng luồng được gọi là python?Phương thức start () Phương thức này được sử dụng để bắt đầu hoạt động của luồng.Khi chúng ta gọi phương thức này, bên trong phương thức Run () được gọi để thực thi hàm đích hoặc đối tượng có thể gọi được.
Làm thế nào để luồng hoạt động trong Python?Việc luồng trong Python được sử dụng để chạy nhiều luồng (tác vụ, cuộc gọi chức năng) cùng một lúc.Lưu ý rằng điều này không có nghĩa là chúng được thực thi trên các CPU khác nhau.Các chủ đề Python sẽ không làm cho chương trình của bạn nhanh hơn nếu nó đã sử dụng thời gian CPU 100 %.Trong trường hợp đó, bạn có thể muốn xem xét lập trình song song.used to run multiple threads (tasks, function calls) at the same time. Note that this does not mean that they are executed on different CPUs. Python threads will NOT make your program faster if it already uses 100 % CPU time. In that case, you probably want to look into parallel programming. |
