精华内容
下载资源
问答
  • py-多线程

    2018-08-22 17:24:38
      理论上会是 但也有可能出现-8     死循环:   

     

    理论上会是 但也有可能出现-8    

     

     

    死循环: 

     

    展开全文
  • ('thread count=1', 16.05018401145935) ('thread count=2', 8.026233196258545) ('thread count=4', 4.011896848678589) ('thread count=8', 2.004067897796631) ('process count=1', 16.032613039016724) ...
  • 最近写个python多线程脚本的时候遇到了一些问题,在windows环境下运行时报错 Unhandled exception in thread started by sys.excepthook is missing lost sys.stderr 发现问题所在:python主线程运行完以后...

    最近写个python多线程脚本的时候遇到了一些问题,在windows环境下运行时报错

    Unhandled exception in thread started by
    sys.excepthook is missing
    lost sys.stderr

    发现问题所在:python主线程运行完以后立即结束了,没有等待子线程。导致了在非idle环境下可能会引起各种问题


    解决方案:

          函数名                                                功能
    run() 如果采用方法2创建线程就需要重写该方法
    getName() 获得线程的名称(方法2中有示例)
    setName() 设置线程的名称
    start() 启动线程
    join(timeout)  在join()位置等待另一线程结束后再继续运行join()后的操作,timeout是可选项,表示最大等待时间
    setDaemon(bool) True:当父线程结束时,子线程立即结束;False:父线程等待子线程结束后才结束。默认为False
    isDaemon() 判断子线程是否和父线程一起结束,即setDaemon()设置的值
    isAlive()  判断线程是否在运行
    使用join或者isDaemon方法,让父线程等待即可



    展开全文
  • 4.2. py4j.clientserver py4j 单线程模型实现py4j.clientserver 模块定义了 python 服务器和 java 客户端的实现, 以确保从 python 或 java 线程启动的命令始终在同一 Java 或 Python 线程上执行。例如, 如果从 java ...

    4.2. py4j.clientserver py4j 单线程模型实现

    py4j.clientserver 模块定义了 python 服务器和 java 客户端的实现, 以确保从 python 或 java 线程启动的命令始终在同一 Java 或 Python 线程上执行。

    例如, 如果从 java UI 线程发送 python 命令, 而 python 代码调用某些 java 代码, 则 java 代码将在 UI 线程中执行。

    Py4J 用户只需要显式地使用 ClientServer 和可选的 JavaParameters PythonParameters其他模块成员都有文档支持扩展 Py4J。

    4.2.1 ClientServer

    classpy4j.clientserver.ClientServer(java_parameters = 无, python_parameters = none, python_server_entry_point = 无)

    实现不同线程模型的 JavaGateway 子类: 线程总是使用与另一侧相同的连接, 因此回调在调用线程中执行。

    例如, 如果 python 线程1调用 java, 而 java 调用 python, 则回调 (从 Java 到 python) 将在 Python 线程1中执行。

    参数:
    • java_parameters –用于配置 JavaGateway (java 客户端) 的参数和标志的集合
    • python_parameters –用于配置 CallbackServer (python 服务器) 的参数和标志的集合
    • 如果 java 正在驱动通信, 则 java 方可以请求python_server_entry_point

    4.2.1.1. 示例

    使用jvm属性:

    >>> clientserver = ClientServer()
    >>> l = clientserver.jvm.java.util.ArrayList()
    >>> l.append(10)
    >>> l.append(1)
    >>> jvm.java.util.Collections.sort(l)
    >>> l
    [1, 10]
    

    ClientServer 类是 JavaGateway 的子类, 与为JavaGateway编写的所有示例和代码完全兼容.`

    4.2.2 JavaParameters

    classpy4j.clientserver.JavaParameters(地址 = ' 127.0. 0.1 ', port=25333, auto_field = 假, auto_close = True, auto_convert = 假, eager_load = 假, ssl_context = 无, enable_memory_management = true, auto_gc = 假, read_timeout = 无, daemonize_memory_management = True)

    包含可传递到配置ClientServer的所有参数的包装类.`

    参数:
    • 地址–客户端将请求连接的地址。如果您使用check_hostname = TrueSSLContext , 则此地址必须与网关服务器提供的证书中的主机名匹配 (其中之一)。
    • 端口–客户端将请求连接的端口。默认值为25333。
    • auto_field -如果False, 通过此网关访问的每个对象都不会尝试查找字段 (只能通过调用 get_field 访问它们)。如果为True, 则字段将自动抬头, 可能隐藏相同名称的方法并使方法调用效率较低。
    • auto_close -如果True, 则客户端创建的连接在垃圾回收时关闭套接字。
    • auto_convert -如果为True, 请尝试自动将 Python 对象 (如序列和映射) 转换为 Java 对象。默认值为False以提高性能, 因为仍然可以显式执行此转换。
    • eager_load -如果True, 网关将尝试通过调用系统来连接到 JVM. currentTimeMillis。如果网关无法连接到 JVM, 它将自动关闭并引发异常。
    • ssl_context (如果不是 None), 将使用此 SSLContext 进行 ssl 连接
    • enable_memory_management -如果为 True, 则当 JavaObject (对 java 边上的对象的引用) 在 Python 端收集垃圾时, 会告诉 Java 方。
    • auto_gc -如果为 True, 则在向 Java 方发送命令之前调用 gc. 收集 ()。这应防止 gc 在发送命令和等待回答之间运行。默认情况下为 False, 因为此情况极不可能发生。旧版选项不再使用。
    • read_timeout –如果 > 0, 则设置一个超时 (以秒为单位), 在此之后, 套接字停止等待来自 Java 端的响应。
    • daemonize_memory_management -如果为 True, 则将 daemonized 进行垃圾回收请求的辅助线程。这意味着 Python 端如果退出, 可能不会发送所有垃圾回收请求。如果为 False, 内存管理将阻止 Python 程序退出, 直到发送所有请求。

    4.2.3 PythonParameters

    classpy4j.clientserver.PythonParameters(地址 = ' 127.0. 0.1 ', port=25334, daemonize = 假, daemonize_connections = 假, eager_load = True, ssl_context = 无, auto_gc = False,接受_timeout = "默认", read_timeout = None)

    包含可传递到配置ClientServer的所有参数的包装类

    参数:
    • 地址–客户端将请求连接的地址
    • 端口–客户端将请求连接的端口。默认值为25333。
    • daemonize -如果True, 将将服务器线程的守护进程属性设置为 True。如果所有其他线程都退出, 回调服务器将自动退出。
    • daemonize_connections -如果True, 则在 daemonized 线程中执行回调服务器连接, 并且在非 daemonized 线程完成时不会阻止程序的退出。
    • eager_load -如果为True, 则在创建 JavaGateway 时会自动启动回调服务器。
    • ssl_context -如果不是 None, 则 SSLContext 的证书将显示回拨连接。
    • auto_gc -如果为 True, 则在返回对 Java 方的响应之前调用 gc. 收集 ()。这应防止 gc 在发送响应和等待新命令之间运行。默认情况下为 False, 因为此情况极不可能, 但可能会中断通信。旧版选项不再使用。
    • accept_timeout –如果 > 0, 则设置超时 (callbackserver 停止等待连接), 查看回调服务器是否应关闭, 如果没有, 请再次等待连接。默认值为5秒: 这大致意味着, 如果可能需要5秒的时间来关闭回调服务器。
    • read_timeout –如果 > 0, 则设置一个超时 (以秒为单位), 在此之后, 套接字停止等待 Java 端的调用或命令。

    4.2.4 JavaClient

    classpy4j.clientserver.JavaClient(java_parameters, python_parameters, gateway_property = 无, finalizer_queue = None)

    负责管理从 Python 到 Java 的请求。

    此实现是线程安全的, 因为每个线程总是只使用一个 ClientServerConnection。

    参数:
    • java_parameters –用于配置 JavaGateway (java 客户端) 的参数和标志的集合
    • python_parameters –用于配置 CallbackServer (python 服务器) 的参数和标志的集合
    • gateway_property -用于保持网关首选项, 而不使用 JavaGateway
    • finalizer_queue –用于管理垃圾回收请求的队列。
    garbage_collect_object(target_id,排队 = True)

    告诉 Java 方面, 在 Python 方面不再引用此 JavaObject。如果排队为 True, 则将请求发送到 FinalizerWorker 队列。否则, 将请求发送到 Java 端。

    get_thread_connection()

    返回与此线程关联的 ClientServerConnection。可以是无。

    set_thread_connection(连接)

    将 ClientServerConnection 与当前线程关联。

    参数:连接–与当前线程关联的 ClientServerConnection。
    shutdown_gateway()

    4.2.5 PythonServer

    classpy4j.clientserver.PythonServer(java_client, java_parameters, python_parameters, gateway_property)

    负责管理从 Java 到 Python 的请求。

    参数:
    • java_client –用于调用 java 对象的网关客户端。
    • java_parameters –用于配置 JavaGateway (java 客户端) 的参数和标志的集合
    • python_parameters –用于配置 CallbackServer (python 服务器) 的参数和标志的集合
    • gateway_property -用于保留网关首选项。

    4.2.6 ClientServerConnection

    classpy4j.clientserver.ClientServerConnection(java_parameters, python_parameters, gateway_property, java_client, python_server = None)

    ClientServer 实例的默认连接 (基于套接字, 每个线程一个) 负责与 Java 虚拟机通信。

    参数:
    • java_parameters –用于配置 JavaGateway (java 客户端) 的参数和标志的集合
    • python_parameters –用于配置 CallbackServer (python 服务器) 的参数和标志的集合
    • gateway_property -用于保留网关首选项。
    • java_client –用于调用 java 对象的网关客户端。
    • python_server –用于从 Java 接收命令的 python 服务器。仅在从 Python 服务器创建时提供。
    close(重置 = False)
    connect_to_java_server()
    init_socket_from_python_server(套接字,)
    run()
    send_command(命令)
    shutdown_gateway()

    将关机命令发送到 Java 端。

    这将关闭 Java 边上的 ClientServer: 所有活动连接都将关闭。如果 Java 程序的生命周期必须与 Python 程序绑定, 这可能会很有用。

    start()
    wait_for_commands()
    展开全文
  • 使用python Multiprocessing模块进行并行、串行、超线程计算实验。计算实例为蒙特卡洛算法计算圆周率Pi。
  • 线程 leetcode MachineLP的工具包: (只是为了自己后面查找代码方便,如有侵犯请微信联系...threads.py:python中的多线程。 img_video.py:将图片转为视频保存。 leetCode: redis-3.0-annotated: ReinforcementLN:
  • 1、多线程的理解 多进程和多线程都可以执行多个任务,线程是进程的一部分。线程的特点是线程之间可以共享 内存和变量,资源消耗少(不过在Unix环境中,多进程和多线程资源调度消耗差距不明显, Unix调度较快),...
  • MPI多线程并行计算工具mpi4py 1. MPI 2. 基本MPI函数 2.1 工具 a. 通信子(通信空间) b. 获取进程 3. 通信 3.1 点对点通信 3.2 群体通信 a. 广播 bcast b. 发散 scatter c. 收集 gather d. 规约 reduce 1. MPI MPI...

    1. MPI

    MPI的全称是Message Passing Interface,即消息传递接口。

    • 它并不是一门语言,而是一个库,我们可以用Fortran、C、C++结合MPI提供的接口来将串行的程序进行并行化处理,也可以认为Fortran+MPI或者C+MPI是一种再原来串行语言的基础上扩展出来的并行语言。
    • 它是一种标准而不是特定的实现,具体的可以有很多不同的实现,例如MPICH、OpenMPI等。
    • 它是一种消息传递编程模型,顾名思义,它就是专门服务于进程间通信的。

    MPI的工作方式很好理解,我们可以同时启动一组进程,在同一个通信域中不同的进程都有不同的编号,程序员可以利用MPI提供的接口来给不同编号的进程分配不同的任务和帮助进程相互交流最终完成同一个任务。就好比包工头给工人们编上了工号然后指定一个方案来给不同编号的工人分配任务并让工人相互沟通完成任务。

    2. 基本MPI函数

    mpi4py是一个构建在MPI之上的Python库,主要使用Cython编写。mpi4py使得Python的数据结构可以方便的在多进程中传递。

    mpi4py是一个很强大的库,它实现了很多MPI标准中的接口,包括点对点通信,组内集合通信、非阻塞通信、重复非阻塞通信、组间通信等,基本上我能想到用到的MPI接口mpi4py中都有相应的实现。不仅是Python对象,mpi4py对numpy也有很好的支持并且传递效率很高。同时它还提供了SWIG和F2PY的接口能够让我们将自己的Fortran或者C/C++程序在封装成Python后仍然能够使用mpi4py的对象和接口来进行并行处理。可见mpi4py的作者的功力的确是非常了得。

    2.1 工具

    a. 通信子(通信空间)

    MPI_COMM_WORLD在MPI中的作用:

    • 一个通信空间是一个进程组和一个上下文的组合.上下文可看作为组的超级标签,用于区分不同的通信子.
    • 在执行函数MPI_Init之后,一个MPI程序的所有进程形成一个缺省的组,这个组的通信子即被写作MPI_COMM_WORLD.
    • 该参数是MPI通信操作函数中必不可少的参数,用于限定参加通信的进程的范围.
    from mpi4py import MPI
                                                    
    MPI.COMM_SELF
    # <mpi4py.MPI.Intracomm at 0x7f2fa2fd59d0>
                                                    
    MPI.COMM_WORLD
    # <mpi4py.MPI.Intracomm at 0x7f2fa2fd59f0>
    

    b. 获取进程

    转到python中的mpi4py

    from mpi4py import MPI
    # 用Get_size 获得进程个数 p
    size = MPI.COMM_WORLD.Get_size()
    # Get_rank 获得进程的一个叫rank的值,
    # 该rank值为0到p-1间的整数,相当于进程的ID号
    rank = MPI.COMM_WORLD.Get_rank()
    

    c++中的定义类似

    int MPI_Comm_size(MPI_Comm comm, int *size)
    int MPI_Comm_rank(MPI_Comm comm, int *rank)
    

    3. 通信

    因为mpi4py中点对点的 通信send语句,在数据量较小的时候是把发送数据拷贝到缓存区,是非堵塞的操作, 然而在数据量较大时候是堵塞操作。
    阻塞操作见 python的MPI多线程并行通信方式

    3.1 点对点通信

    所谓点对点通信,即单个线程与单个线程之间通信。

    (a) 两个线程之间点对点通信。

    # test.py
    from mpi4py import MPI
    
    comm = MPI.COMM_WORLD
    rank = comm.Get_rank()
    
    if rank == 0:
        data = {'a': 7, 'b': 3.14}
        comm.send(data, dest=1, tag=11)
        data['a'] = 8; data['b'] = data['b'] * 2
    
    elif rank == 1:
        data = comm.recv(source=0, tag=11)
    print('{}_{}'.format(rank, data))
    

    结果为:

    mpiexec -n 2 python test.py     # -n/-np  means number of process
    # result
    0_{'a': 8, 'b': 6.28}
    1_{'a': 7, 'b': 3.14}
    

    (b) 多个线程之间点对点通信

    如下面例子的5个线程之间点对点通信,一个接着一个通信之间通信,形成一个圈(rank_3 => rank_4 => rank_0 => rank_1 => rank_2 => rank_3)。

    # test.py
    import mpi4py.MPI as MPI
     
    comm = MPI.COMM_WORLD
    comm_rank = comm.Get_rank()      # id number
    comm_size = comm.Get_size()      # number of mpi
    
    # point to point communication
    data_send = [comm_rank+1]*5
    
    comm.send(data_send,dest=(comm_rank+1)%comm_size)
    data_recv =comm.recv(source=(comm_rank-1)%comm_size)
    
    print("my rank is %d, and I received:" % comm_rank)
    print(data_recv)
    

    运行该文件:

    mpiexec -n 5 python test.py
    # result
    my rank is 3, and I received:
    [3, 3, 3, 3, 3]
    my rank is 0, and I received:
    [5, 5, 5, 5, 5]
    my rank is 4, and I received:
    [4, 4, 4, 4, 4]
    my rank is 1, and I received:
    [1, 1, 1, 1, 1]
    my rank is 2, and I received:
    [2, 2, 2, 2, 2]
    

    解释:(rank_3 => rank_4 => rank_0 => rank_1 => rank_2 => rank_3)
    例如,当前进程id=3,其data_send = [comm_rank+1]*5为[4, 4, 4, 4, 4], 而该进程发送时,所设定的dest=(comm_rank+1)%comm_size)=4,接收设定为source=3,因此rank=3原本的数据[4, 4, 4, 4, 4],发送到目标dest=4,所以rank=4所接收到的数据为[4, 4, 4, 4, 4],而rank=3自己接收的来源source=3,故dest计算等于3的为rank=2,所以id=3获取其数据[3, 3, 3, 3, 3],并打印出来。

    如果修改到如下情况,则多线程之间可以按照顺序点对点的通信,即(rank_1 => rank_2 => rank_3 => rank_4 => rank_0 => rank_1)

    import mpi4py.MPI as MPI
         
    comm = MPI.COMM_WORLD
    comm_rank = comm.Get_rank()
    comm_size = comm.Get_size()
    data_send = [comm_rank+1]*5
    
    if comm_rank == 0:
       comm.send(data_send, dest=(comm_rank+1)%comm_size)
    
    if comm_rank > 0:
       data_recv = comm.recv(source=(comm_rank-1)%comm_size)
       comm.send(data_send, dest=(comm_rank+1)%comm_size)
    
    if comm_rank == 0:
       data_recv = comm.recv(source=(comm_rank-1)%comm_size)
    
    print("my rank is %d, and Ireceived:" % comm_rank)
    print(data_recv)
    

    3.2 群体通信

    a. 广播 bcast

    广播操作是典型的一对多通信,将跟进程的数据复制到同组内其他所有进程中。
    在这里插入图片描述

    from mpi4py import MPI                                                     
                                                                               
    comm = MPI.COMM_WORLD                                                      
    rank = comm.Get_rank()                                                     
    size = comm.Get_size()                                                     
                                                                               
    if rank == 0:                                                              
        data = list(range(10))                                                       
        print("process {} bcast data {} to other processes".format(rank, data))
    else:                                                                      
        data = None                                                            
    data = comm.bcast(data, root=0)                                            
    print("process {} recv data {}...".format(rank, data))
    
    mpiexec -n 5 python test.py
    # result
    process 0 bcast data [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] to other processes
    process 0 recv data [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]...
    process 1 recv data [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]...
    process 4 recv data [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]...
    process 2 recv data [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]...
    process 3 recv data [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]...
    

    b. 发散 scatter

    与广播不同,发散可以向不同的进程发送不同的数据,而不是完全复制。
    在这里插入图片描述

    from mpi4py import MPI                                                            
    import numpy as np                                                                
                                                                                      
    comm = MPI.COMM_WORLD                                                             
    rank = comm.Get_rank()                                                            
    size = comm.Get_size()                                                            
                                                                                      
    recv_data = None                                                                  
                                                                                      
    if rank == 0:                                                                     
        send_data = list(range(5))                                                         
        print("process {} scatter data {} to other processes".format(rank, send_data))
    else:                                                                             
        send_data = None                                                              
    recv_data = comm.scatter(send_data, root=0)                                       
    print("process {} recv data {}...".format(rank, recv_data))
    
    mpiexec -n 5 python test.py
    

    c. 收集 gather

    收集过程是发散过程的逆过程,每个进程将发送缓冲区的消息发送给根进程,根进程根据发送进程的进程号将各自的消息存放到自己的消息缓冲区中。
    在这里插入图片描述

    from mpi4py import MPI                                              
    import numpy as np                                                  
                                                                        
    comm = MPI.COMM_WORLD                                               
    rank = comm.Get_rank()                                              
    size = comm.Get_size()                                              
                                                                        
    send_data = rank                                                    
    print "process {} send data {} to root...".format(rank, send_data)  
    recv_data = comm.gather(send_data, root=0)                          
    if rank == 0:                                                       
        print "process {} gather all data {}...".format(rank, recv_data)
    
    mpiexec -n 5 python test.py
    

    d. 规约 reduce


    参考资料:
    [1] https://mpi4py.readthedocs.io/en/latest/tutorial.html
    [2] https://mpitutorial.com/tutorials/mpi-introduction/
    [3] https://zhuanlan.zhihu.com/p/25332041
    [4] https://www.cnblogs.com/devilmaycry812839668/p/9484644.html
    [5] https://blog.csdn.net/ZuoShifan/article/details/80024380
    [6] https://www.zybuluo.com/Purpose/note/700033
    [7] https://rabernat.github.io/research_computing/parallel-programming-with-mpi-for-python.html

    展开全文
  • 如上所述:启动代理池时发现需要同时启动两个py文件,但是每次去找到两个不再同一个位置的文件然后启动它们特别麻烦。 于是,我想在一个py文件中进行代理池调用的集成。 在启动这个代理池时遇...
  • global num #在每个线程中都获取这个全局变量 #num-=1 temp=num time.sleep(0.1) # 模拟耗时0.1s 已经线程已经进行抢占资源,数据则不安全!在0.1s中足以遍历100个线程进行赋值,快到将所有的num都赋值成100 ...
  • D:\code\mutil_process下创建文件apply_2_program.py #coding=utf-8 import time # from selenium import webdriver import threading import os def fun1(a): print(a) def fun2(): print(222) def process_...
  • 线程和多线程

    2020-11-04 22:13:24
    线程和多线程线程 普通的程序默认都是单线程,程序的执行方式是从上至下串行执行,示例 import time def func(a,b): time.sleep(1) print(a+b) s = time.time() func(5,10) func(2,5) func(6,84) func(9,46) ...
  • python多线程库Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。_thread 提供了低级别的、原始的线程...python多线程实现1main.pymain.py在这里有2个函数:workA(job)和workB(job) 2个实际工作的...
  • 线程编程 - 单线程和多线程执行对比 递归求斐波那契、阶乘与累加函数的执行。该脚本按照单线程的方式运行这三个函数,之后使用多线程的方式执行同样的任务,用来说明多线程环境的优点。 以单线程模式运行时,...
  • Python 线程

    千次阅读 2019-06-06 17:54:45
    线程,有时被称为轻量进程,是程序执行流的最小单元。一个标准的线程线程ID,当前指令指针(PC),寄存器集合和堆栈组成。线程是进程中的一个实体,是被系统独立调度和分派的基本单位,线程不拥有私有的系统资源,...
  • python多线程详解(超详细)

    万次阅读 多人点赞 2019-09-28 08:33:31
    python中的多线程是一个非常重要的知识点,今天为大家对多线程进行详细的说明,代码中的注释有多线程的知识点还有测试用的实例。 import threading from threading import Lock,Thread import time,os ''' python...
  • 文章目录线程的基本信息 线程的基本信息 对于线程,可以为线程起名字、获取名字、获取状态、设置优先级、获得当前运行的线程对象。代码如下: public class test { public static void main(String[] args) { ...
  • #!/home/online/bin/python/bin/python ...# for2thread.py # sinomazing # http://hi.baidu.com/sinomazing/blog/item/bf29c1ee40865d232cf53445.html # .for........... from time import ctime,slee
  • c单线程及多线程处理python1. c单线程处理python2. c多线程处理 python 踩坑教训2.1 主线程 初始化代码2.2 主线程 去初始化代码2.3 c线程python处理:参考: 1. c单线程处理python …… #include <python3.7m/...
  • 编写一个多线程的Python服务器。 多线程Python服务器使用以下主要模块来管理多个客户端连接。 1. Python的线程模块 2. SocketServer的 ThreadingMixIn 上述两个模块中的第二个类使得Python服务器能够分叉新线程来...
  • python – 多线程SocketServer———1.多线程SocketServer链接,客户端不显示命令内容————————- 服务器端:root@kali:~/python/socket# pwd ...ftp socket_server_mult_line.py socket_server_
  • python的threading模块有提供多线程的执行方法,在计算密集型操作里也用不上,很多时候是在处理IO密集型的操作里使用,能为我们节省不少时间,但他本身不提供获取线程执行结果,需要我们自行实现,目前最简单的办法...
  • python多线程,线程

    万次阅读 2019-01-19 23:39:10
    python使用多线程, 不一定运行速度快,这里引入GIL(global interpreter lock) python解释器中任意时刻都只有一个线程在执行; GIL执行过程: 1). 设置一个GIL; 2). 切换线程去准备执行任务(Runnale就绪状态)...
  • 一、多线程(主线程和子线程同时执行) 1、主线程是程序本身,看不到的,主线程和子线程没有依赖关系,同步执行的,若主线程先执行完,会等子线程执行完毕,程序结束 2、启动一个线程就是把一个函数传入并创建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,489
精华内容 22,595
关键字:

py线程