python线程函数传参 python 多线程 传参

python 像这样定义多线程的类在调用时怎么把调用父类的参数传递给子函数

你已经实现了啊。在__init__初始化参数里，将参数传递进去。

另外因为线程工作在主程序同一个空间里，所以可以用全局变量传递。比如定义一个global v，然后在主程序里设置好。

再在线程里用global v来引用。

如果在线程运行当中，动态的改参数。可以象是这里的thread_stop设置。由主进程与从进程单对单的传递信号。

另外还可以通过队列。这个好处是有一个锁，可以全局使用。

此外你还可以引入一个消息管理器。各个线程与主进程直接通过消息传递变量。

进程之间也可以通过共享内存来实现RPC通信，就是交换数据。

线程处理完的数据，如果主程序想处理。可以这样。让线程通过全局变量，通过队列传回来。

不过主进程通常还有一个任务，就是监督线程的完成退处，并管理线程中止信号。

比如你这个程序少了一个

thread.join() 这里的join可以加一个timeout，当超时时，主进程就可以脱身出来，做一些其它的事情，比如处理返回数值。 如果线程通过一个数组变量将状态传回主进程。这样轮洵子线程状态会比join的效率更高。

你这个程序里用文件传递也不是不可以。这是一个很好思路。当你传递变量困难时，可以用文件。或者是数据库。

相关问答

Q1: python多线程thread.start_new_thread传参的问题

因为thread.start_new_thread(ssh_cmd,(3,))开的线程会和主线程一起结束，所以等不到执行print number 程序就结束了

Q2: Python 多线程传参问题

下面是从python  threading模块摘录下来python线程函数传参的

class threading.Thread(group=None, target=None,

name=None, args=(), kwargs={})

args is the argument tuple for the target invocation. Defaults to

().

kwargs is a dictionary of keyword arguments for the target

invocation. Defaults to {}.

简单python线程函数传参的说就是python线程函数传参，线程函数的参数要么是tuple类型要么是dict类型，既然python文档上已经规定好了，那么就是不能变了，除非重大的版本升级，弃用现在这种方式，不过这是不可能的，再者可以查看threading.Thread类的初始化代码

class Thread(_Verbose):    

    def __init__(self, group=None, target=None, name=None,

                 args=(), kwargs=None, verbose=None):

        assert group is None, "group argument must be None for now"

        _Verbose.__init__(self, verbose)

        if kwargs is None:

            kwargs = {}

        self.__target = target

        self.__name = str(name or _newname())

        self.__args = args

        self.__kwargs = kwargs

        self.__daemonic = self._set_daemon()

        self.__ident = None

        self.__started = Event()

        self.__stopped = False

        self.__block = Condition(Lock())

        self.__initialized = True

        # sys.stderr is not stored in the class like

        # sys.exc_info since it can be changed between instances

        self.__stderr = _sys.stderr

看到上面的args和kwargs的赋值情况吗，python线程函数传参你不能像**kwargs这样来传参的。

从上面来看，你要使用多线程你就必须遵守这个约定，线程函数参数要么是tuple,要么是字典，没办法改进。非要改进那就是使用全局变量，不用传参，但是如果是这样的话会涉及到线程安全的问题或者叫数据同步问题，如果不加锁或者其python线程函数传参他互斥量的话这个问题会很严重。所以还是遵守规定吧

Q3: python 已经启动的线程 怎么往里面传参数

把参数放到Queue里,线程从Queue里获得参数,Queue是线程安全python线程函数传参的

Q4: python多线程 怎么传送多个参数

import threadpool  

import time  

  

def Main_Def(par1, par2, par3):  

    print "par1 = %s, par2 = %s, par3 = %s" % (par1, par2, par3)  

  

  

if __name__ == '__main__':  

    # 方法1  

    list_var1 = ['1', '2', '3']  

    list_var2 = ['4', '5', '6']  

    par_list = [(list_var1, None), (list_var2, None)]  

    # 方法2  

    # dict_var1 = {'par1': '1', 'par2': '2', 'par3': '3'}  

    # dict_var2 = {'par1': '4', 'par2': '5', 'par3': '6'}  

    # par_list = [(None, dict_var1), (None, dict_var2)]  

  

    pool = threadpool.ThreadPool(2)  

    requests = threadpool.makeRequests(Main_Def, par_list)  

    [pool.putRequest(req) for req in requests]  

    time.sleep(1)  

    pool.wait()

Q5: python3 创建线程时不用args传参，执行线程时为什么不是同时执行？

在Python多线程下，每个线程的执行方式：

1、获取GIL

2、执行代码直到sleep或者是python虚拟机将其挂起。

3、释放GIL

可见，某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。

在Python2.x里，GIL的释放逻辑是当前线程遇见IO操作或者ticks计数达到100（ticks可以看作是Python自身的一个计数器，专门做用于GIL，每次释放后归零，这个计数可以通过

sys.setcheckinterval 来调整），进行释放。

而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。

那么是不是python的多线程就完全没用了呢？

在这里我们进行分类讨论：

1、CPU密集型代码(各种循环处理、计数等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。

2、IO密集型代码(文件处理、网络爬虫等)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。

而在python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL），这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。

请注意：多核多线程比单核多线程更差，原因是单核下多线程，每次释放GIL，唤醒的那个线程都能获取到GIL锁，所以能够无缝执行，但多核下，CPU0释放GIL后，其他CPU上的线程都会进行竞争，但GIL可能会马上又被CPU0拿到，导致其他几个CPU上被唤醒后的线程会醒着等待到切换时间后又进入待调度状态，这样会造成线程颠簸(thrashing)，导致效率更低

回到最开始的问题：经常我们会听到老手说：“python下想要充分利用多核CPU，就用多进程”，原因是什么呢？

原因是：每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，所以在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。

所以在这里说结论：多核下，想做并行提升效率，比较通用的方法是使用多进程，能够有效提高执行效率

关于python线程函数传参和python 多线程 传参的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。