Python中的并发编制程序实例,python并发编制程序实例

  多进度能够被用来必要同不经常候实践多少个义务的气象,由差异的长河担当职责的例外界分。然则,另一种将职业细分到职分的措施是行使线程。同进度类似,线程也许有其和煦的调节流以及推行栈,但线程在创制它的历程之内运维,分享其父进度的兼具数据和系统能源。当使用供给做到并发职责的时候线程是很有用的,然则潜在的主题素材是天职间必须享受大量的体系状态。

  多进度能够被用于需求同期实践三个职务的气象,由差别的经过担负职分的不如部分。然则,另一种将工作细分到职务的点子是利用线程。同进度类似,线程也许有其自身的调节流以及推行栈,但线程在成立它的进度之内运转,分享其父进度的富有数据和系统财富。当使用须求做到并发职分的时候线程是很有用的,然则潜在的主题材料是天职间必须享受多量的连串状态。

Python中的并发编制程序实例,python并发编制程序实例

一、简介

  大家将三个正在运作的次序名称为进度。每种进度都有它本人的系统状态,包蕴内部存款和储蓄器状态、张开文件列表、追踪指令执涨势况的顺序指针以及贰个封存局地变量的调用栈。平常景况下,二个历程根据一个单连串调控流顺序施行,这一个调整流被叫做该进程的主线程。在其余给定的随时,二个顺序只做一件业务。

  贰个顺序能够经过Python库函数中的os或subprocess模块创建新进度(比方os.fork()或是subprocess.Popen())。不过,那几个被称为子进度的经过却是独立运营的,它们有分别独立的类别状态以及主线程。因为经过之间是相互独立的,因而它们同原有的进程并发推行。那是指原经过能够在创制子进度后去推行别的职业。

  尽管经过之间是互相独立的,可是它们能够因此名字为经过间通信(IPC)的机制举办相互通讯。三个独立的形式是依附新闻传递,可以将其差非常少地领略为一个纯字节的缓冲区,而send()或recv()操作原语能够透过诸如管道(pipe)或是网络套接字(network
socket)等I/O通道传输或收受音信。还应该有一对IPC形式能够通过内部存款和储蓄器映射(memory-mapped)机制达成(举例mmap模块),通过内部存款和储蓄器映射,进度能够在内部存款和储蓄器中开创分享区域,而对那个区域的改造对富有的经过可知。

  多进程能够被用来必要同期试行多少个任务的现象,由不相同的经过肩负职务的不如部分。然则,另一种将专门的学问细分到职分的措施是利用线程。同进度类似,线程也可能有其和谐的调控流以及实行栈,但线程在开创它的进度之内运营,分享其父进程的具备数据和系统能源。当使用供给完结并发职分的时候线程是很有用的,可是潜在的难点是职分间必须享受多量的系统状态。

  当使用多进度或八线程时,操作系统肩负调治。那是通过给各类进程(或线程)三个不大的时间片并且在具备活动任务之间火速循环切换成实现的,那一个进度将CPU时间分开为小片段分给各种职责。举例,假如你的系统中有11个活泼的进程正在试行,操作系统将会适当的将十分一的CPU时间分配给种种进度并且循环地在十三个经过之间切换。当系统不断有一个CPU核时,操作系统可以将经过调解到区别的CPU核上,保持系统负荷平均以落到实处并行奉行。

  利用并发实践机制写的次第要求考虑部分眼花缭乱的难点。复杂性的尤为重要来自是有关联合和分享数据的主题材料。平时景况下,多个职责同不经常常候试图更新同贰个数据结构会招致脏数据和顺序状态区别样的题材(正式的传道是财富竞争的标题)。为了消除这些标题,要求采取互斥锁或是其余一般的协同原语来标记并珍重程序中的关键部分。比如,若是五个不等的线程正在希图同一时间向同叁个文本写入数据,那么您供给二个排斥锁使那一个写操作依次实践,当一个线程在写入时,别的线程必须等待直到方今线程释放这么些财富。

Python中的并发编程

  Python长期以来平素帮衬不相同格局的面世编制程序,包蕴线程、子进度以及其余使用生成器(generator
function)的出现完成。

  Python在大部种类上还要援救音讯传递和基于线程的面世编制程序机制。即便抢先百分之五十程序猿对线程接口更为熟谙,可是Python的线程机制却有着广大的界定。Python使用了内部全局解释器锁(GIL)来担保线程安全,GIL同期只允繁多个线程实践。那使得Python程序就算在多核系统上也只可以在单个管理器上运营。Python界关于GIL的争论纵然十分的多,但在可预感的以往却绝非将其移除的或然。

  Python提供了一些很精致的工具用于管理基于线程和进度的面世操作。即便是粗略地先后也能够利用那个工具使得职务并发举办进而加速运行速度。subprocess模块为子过程的创导和通讯提供了API。那特别契合运营与公事相关的次序,因为那一个API协理通过新进度的规范输入输出通道传送数据。signal模块将UNIX系统的频域信号量机制暴光给用户,用以在经过之间传递事件新闻。频域信号是异步管理的,平时有时域信号到来时会中断程序当前的干活。确定性信号机制可以完结粗粒度的新闻传递系统,可是有别的更可信的经过内通信技能能够传递更复杂的音讯。threading模块为出现操作提供了一多元高等的,面向对象的API。Thread对象们在多个经过内并发地运维,分享内部存款和储蓄器能源。使用线程能够更加好地庞大I/O密集型的职分。multiprocessing模块同threading模块类似,但是它提供了对于经过的操作。每一种进度类是实在的操作系统进度,并且未有分享内部存款和储蓄器财富,但multiprocessing模块提供了经过间分享数据以及传递音讯的体制。平常意况下,将依赖线程的主次改为基于进度的相当粗略,只需求修改部分import表明就可以。

Threading模块示例

  以threading模块为例,思考那样一个简单易行的难题:如何使用分段并行的法子成就二个天机的丰裕。

import threading

class SummingThread(threading.Thread):
  def __init__(self, low, high):
    super(SummingThread, self).__init__()
    self.low = low
    self.high = high
    self.total = 0

  def run(self):
    for i in range(self.low, self.high):
      self.total += i

thread1 = SummingThread(0, 500000)
thread2 = SummingThread(500000, 1000000)
thread1.start() # This actually causes the thread to run
thread2.start()
thread1.join() # This waits until the thread has completed
thread2.join()
# At this point, both threads have completed
result = thread1.total + thread2.total
print(result)

自定义Threading类库

  笔者写了一个轻便使用threads的MiniPython类库,富含了部分灵光的类和函数。

重在参数:

  * do_threaded_work –
该函数将一密密麻麻给定的职务分配给相应的管理函数(分配顺序不分明)

  * ThreadedWorker –
该类成立二个线程,它将从一个合伙的劳作行列中拉取专门的学业职务并将管理结果写入同步结果队列

  * start_logging_with_thread_info –
将线程id写入全数日志新闻。(依赖日志意况)

  * stop_logging_with_thread_info –
用于将线程id从持有的日记新闻中移除。(正视日志情况)

import threading
import logging

def do_threaded_work(work_items, work_func, num_threads=None, per_sync_timeout=1, preserve_result_ordering=True):
  """ Executes work_func on each work_item. Note: Execution order is not preserved, but output ordering is (optionally).

    Parameters:
    - num_threads        Default: len(work_items) --- Number of threads to use process items in work_items.
    - per_sync_timeout     Default: 1        --- Each synchronized operation can optionally timeout.
    - preserve_result_ordering Default: True       --- Reorders result_item to match original work_items ordering.

    Return: 
    --- list of results from applying work_func to each work_item. Order is optionally preserved.

    Example:

    def process_url(url):
      # TODO: Do some work with the url
      return url

    urls_to_process = ["http://url1.com", "http://url2.com", "http://site1.com", "http://site2.com"]

    # process urls in parallel
    result_items = do_threaded_work(urls_to_process, process_url)

    # print(results)
    print(repr(result_items))
  """
  global wrapped_work_func
  if not num_threads:
    num_threads = len(work_items)

  work_queue = Queue.Queue()
  result_queue = Queue.Queue()

  index = 0
  for work_item in work_items:
    if preserve_result_ordering:
      work_queue.put((index, work_item))
    else:
      work_queue.put(work_item)
    index += 1

  if preserve_result_ordering:
    wrapped_work_func = lambda work_item: (work_item[0], work_func(work_item[1]))

  start_logging_with_thread_info()

  #spawn a pool of threads, and pass them queue instance 
  for _ in range(num_threads):
    if preserve_result_ordering:
      t = ThreadedWorker(work_queue, result_queue, work_func=wrapped_work_func, queue_timeout=per_sync_timeout)
    else:
      t = ThreadedWorker(work_queue, result_queue, work_func=work_func, queue_timeout=per_sync_timeout)
    t.setDaemon(True)
    t.start()

  work_queue.join()
  stop_logging_with_thread_info()

  logging.info('work_queue joined')

  result_items = []
  while not result_queue.empty():
    result = result_queue.get(timeout=per_sync_timeout)
    logging.info('found result[:500]: ' + repr(result)[:500])
    if result:
      result_items.append(result)

  if preserve_result_ordering:
    result_items = [work_item for index, work_item in result_items]

  return result_items

class ThreadedWorker(threading.Thread):
  """ Generic Threaded Worker
    Input to work_func: item from work_queue

  Example usage:

  import Queue

  urls_to_process = ["http://url1.com", "http://url2.com", "http://site1.com", "http://site2.com"]

  work_queue = Queue.Queue()
  result_queue = Queue.Queue()

  def process_url(url):
    # TODO: Do some work with the url
    return url

  def main():
    # spawn a pool of threads, and pass them queue instance 
    for i in range(3):
      t = ThreadedWorker(work_queue, result_queue, work_func=process_url)
      t.setDaemon(True)
      t.start()

    # populate queue with data  
    for url in urls_to_process:
      work_queue.put(url)

    # wait on the queue until everything has been processed   
    work_queue.join()

    # print results
    print repr(result_queue)

  main()
  """

  def __init__(self, work_queue, result_queue, work_func, stop_when_work_queue_empty=True, queue_timeout=1):
    threading.Thread.__init__(self)
    self.work_queue = work_queue
    self.result_queue = result_queue
    self.work_func = work_func
    self.stop_when_work_queue_empty = stop_when_work_queue_empty
    self.queue_timeout = queue_timeout

  def should_continue_running(self):
    if self.stop_when_work_queue_empty:
      return not self.work_queue.empty()
    else:
      return True

  def run(self):
    while self.should_continue_running():
      try:
        # grabs item from work_queue
        work_item = self.work_queue.get(timeout=self.queue_timeout)

        # works on item
        work_result = self.work_func(work_item)

        #place work_result into result_queue
        self.result_queue.put(work_result, timeout=self.queue_timeout)

      except Queue.Empty:
        logging.warning('ThreadedWorker Queue was empty or Queue.get() timed out')

      except Queue.Full:
        logging.warning('ThreadedWorker Queue was full or Queue.put() timed out')

      except:
        logging.exception('Error in ThreadedWorker')

      finally:
        #signals to work_queue that item is done
        self.work_queue.task_done()

def start_logging_with_thread_info():
  try:
    formatter = logging.Formatter('[thread %(thread)-3s] %(message)s')
    logging.getLogger().handlers[0].setFormatter(formatter)
  except:
    logging.exception('Failed to start logging with thread info')

def stop_logging_with_thread_info():
  try:
    formatter = logging.Formatter('%(message)s')
    logging.getLogger().handlers[0].setFormatter(formatter)
  except:
    logging.exception('Failed to stop logging with thread info')

 使用示例

from test import ThreadedWorker
from queue import Queue

urls_to_process = ["http://facebook.com", "http://pypix.com"]

work_queue = Queue()
result_queue = Queue()

def process_url(url):
  # TODO: Do some work with the url
  return url

def main():
  # spawn a pool of threads, and pass them queue instance 
  for i in range(5):
    t = ThreadedWorker(work_queue, result_queue, work_func=process_url)
    t.setDaemon(True)
    t.start()

  # populate queue with data  
  for url in urls_to_process:
    work_queue.put(url)

  # wait on the queue until everything has been processed   
  work_queue.join()

  # print results
  print(repr(result_queue))

main()

Python中的并发编制程序,Python并发编制程序

  小编写了多少个便于使用threads的微型Python类库,包蕴了有的管用的类和函数。

  Python在繁多种类上还要援救音讯传递和依据线程的出现编制程序机制。即使许多技师对线程接口更为熟稔,可是Python的线程机制却具备众多的限定。Python使用了当中全局解释器锁(GIL)来保险线程安全,GIL相同的时候只同意一个线程施行。那使得Python程序尽管在多核系统上也只辛亏单个管理器上运营。Python界关于GIL的争持尽管非常的多,但在可预感的前景却从没将其移除的大概。

python编制程序中的多个排列组合难点

99天,每1私有能够分别和其他玖拾玖位配成对。。
 

一、简要介绍大家将多少个正值周转的次第名叫进度。各种过程都有它协和的系统状态,包涵内存状…

简介

  我们将二个正值周转的顺序名称叫进程。各个进程都有它协调的系统状态,包涵内存状态、张开文件列表、追踪指令执增势况的次序指针以及一个保存局地变量的调用栈。常常状态下,贰个历程依照一个单连串调整流顺序推行,那个调控流被称呼该进程的主线程。在其余给定的时刻,四个先后只做一件业务。

  叁个顺序可以透过Python库函数中的os或subprocess模块创造新进程(例如os.fork()或是subprocess.蒲柏n())。但是,那一个被称为子进度的进度却是独立运作的,它们有分别独立的体系状态以及主线程。因为经过之间是互为独立的,由此它们同原有的历程并发执行。那是指原经过能够在创制子进度后去推行别的专门的学问。

  尽管进度之间是并行独立的,可是它们能够透过名叫经过间通讯(IPC)的编写制定进行互动通信。三个优秀的方式是基于音信传递,能够将其轻便地精晓为多少个纯字节的缓冲区,而send()或recv()操作原语可以经过诸如管道(pipe)或是网络套接字(network
socket)等I/O通道传输或接收消息。还会有部分IPC形式能够通过内部存款和储蓄器映射(memory-mapped)机制产生(比如mmap模块),通过内存映射,进度能够在内部存款和储蓄器中开创分享区域,而对那几个区域的改换对持有的长河可知。

  多进度可以被用于供给相同的时间实施多个义务的光景,由不一致的长河负权利务的不一样部分。不过,另一种将专业细分到职分的法子是运用线程。同进度类似,线程也会有其和睦的调控流以及实行栈,但线程在创立它的历程之内运维,分享其父进度的装有数据和系统能源。当使用须求做到并发职责的时候线程是很有用的,不过潜在的主题素材是职责间必须享受多量的系列状态。

  当使用多进度或二十四线程时,操作系统担任调整。那是因此给每一个进度(或线程)叁个一点都不大的时间片并且在有着移动职务之间非常的慢循环切换到达成的,那些进度将CPU时间分开为小片段分给各样职责。比方,如若您的种类中有11个活泼的经过正在施行,操作系统将会适度的将10%的CPU时间分配给每种进度並且循环地在11个进度之间切换。当系统持续有三个CPU核时,操作系统能够将经过调整到区别的CPU核上,保持系统负荷平均以贯彻并行试行。

  利用并发试行机制写的程序必要怀念部分目不暇接的主题材料。复杂性的机要缘于是关于联合和分享数据的标题。平时状态下,八个职责同有时候试图更新同三个数据结构会导致脏数据和次序状态不雷同的标题(正式的说教是财富竞争的难题)。为了减轻那几个难点,要求运用互斥锁或是其他一般的协同原语来标志并保险程序中的关键部分。比方,固然多个例外的线程正在试图同有的时候间向同叁个文件写入数据,那么你要求一个排斥锁使那一个写操作依次实践,当一个线程在写入时,其余线程必须等待直到当前线程释放这几个财富。

  大家将贰个正值运行的次序名称叫进度。各样进程皆有它自身的体系状态,包蕴内部存款和储蓄器状态、打开文件列表、追踪指令执市场价格况的程序指针以及三个保存局地变量的调用栈。平日意况下,二个经过依据二个单类别调节流顺序实施,那几个调控流被喻为该进程的主线程。在另外给定的时刻,三个程序只做一件业务。

  利用并发实践机制写的主次要求思索部分错综相连的主题素材。复杂性的首要性来源是关于联合和共享数据的题目。平常状态下,七个职务同不常间策动更新同四个数据结构会产生脏数据和次序状态不均等的标题(正式的布道是财富竞争的标题)。为了缓和那个问题,需求选拔互斥锁或是别的一般的协同原语来标记并保证程序中的关键部分。比方,假若多少个例外的线程正在试图同期向同一个文件写入数据,那么您必要二个排斥锁使那些写操作依次实施,当二个线程在写入时,其余线程必须等待直到近年来线程释放这几个能源。

怎通晓python编制程序中类品种对象的实例等等

类正是一类东西的回顾,举个例子人。
种类是数据类型,有停放的如字符串,数字,复数等,还恐怕有另外自定义的,正是投机写的类。
目的和实例是叁个事物,是类里具体的事物,如汉子,女子,别的人等,这里汉子,女子还是能是一类,如再分年老的先生,年轻的先生等。
一经记住:类是一类东西的统称,实例(或对象)是实际的事物。
仅供参照他事他说加以考察。
举例:
class Person:
”’人的主题属性:名字,年龄,性别等”’
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex

class Man(Person):
def __init__(self, name, age):
super(Man, self).__init__(name, age, ‘male’)

class Woman(Person):
def __init__(self, name, age):
super(Woman, self).__init__(name, age, ‘female’)
 

Python 在编程语言中是什地位?为什么相当多高校不教 Python?

足够想炮轰一下,所谓「高校念书的主导安插观念,老师上课一两张言语就可以,关键自个儿得去商讨,看自身喜欢什么就去多看多演练多钻研才方可」根本就站不住脚。首先,既然是教师一两门语言,为什么那门语言是C实际不是python?教师怎么着语言,跟你怎么技巧把计算机语言写好跟你要切磋,完全正是四遍事。(小编并不否定重申学习要有色金属研商所究的饱满,小编那一个确认在未曾别的办法的情形下用这种论调来自己安慰,不过以为钻研的精神最首要,学习怎么东西不主要,并不是一个令人甘休思虑的好答案)从国内的Computer科学施教来看,「Computer语言」(电脑Language)其实历来未有拿走非常高的地方,在咀嚼上就从未当真把Computer语言拉到叁个较高的等第来看,相反的,恐怕还会有鄙视代码,感到语言只是知识的尾巴部分,不是上场合有得探讨的事物。出现这种境况的原因小编相当小清楚,反正自个儿身边非常多的教授其实都以日常跑跑算法就行了——用自身用熟的C来跑,完全丰裕了。如若你的代码只是用来演示三个小程序的算法,实际上就是一个伪代码到能够编译的代码的变通,其实真就是绝非多大分别了。想想什么老师在教计算机语言?基本皆以教数据结构啊、算法啊之类的拉过来客串一下,这一个教授一再未有面对纷纭的系统的经验,也从没对四个有表达力的言语的急需在。而Computer语言的区分,所谓的表明力,优雅,抽象的角度,思维,全体都不是能够发到paper的事物,都以的确须要将语言工具用于选择和抽象本事体味到的。老师实际上一无使用一门好的言语的须求,二也相当少做那么些切磋的。Computer语言被拆成了众多门课,从言语、抽象和希图的角度来察看语言自身,高校应该是从没有过这种课程的。以大家高校来讲,程序设计1一直就不是教程序设计,就是贰个充水的C语言参照他事他说加以考察指引,程序设计2亦非教程序设计,便是叁个充水的C++语言仿效顺便教你用C++的OO语法来完成点数据结商谈算法。你确实使用Computer语言是因为您要写数据结交涉算法的功课。然后呢?因为要学计组你才要求学点汇编,一些老师可能对编制程序语言最大的认识是win32写个贪吃蛇。然后等到您大三了你学「编写翻译原理」的时候是教你怎么着兑现二个编写翻译器(并非哪些规划一门语言,用语言来研讨和架空)。高校既不是专业人才教育,亦非通才教育。高校是基本本事教育,它独有职分教会大好些个上学的儿童在他规范领域中的基本力量。那句话本没错,不过那句模糊的话,实际上却造成了放弃二个更加好的取舍的借口。高校自然不是专业人才教育,大学是骨干力量教育也远非错,然而,使用C一定是通晓主旨本事的最棒选取呢?下面扯的「python非常不够clean」,「Python
的集成性并不比 C
好」也站不住脚。python在大非常多情况下都比C要clean多了啊。。。高校教育哪儿会在乎你的集成性。大家用
Python
是因为它的财富能够支持众三人化解难点,这几个大概笔者也承认。可是,python除了类库丰硕,依然有很多好东西的。从言语上看,python远远比C更合乎教学啊。比如,python会让您的
1 < a < 2 是对的,不会令你栽入C的所谓的 (1<a)
是三个布尔值,然后跟2相比较——这种规划真就是对的吗?人类真的就活该退让这种设计啊?然后别说scanf(“%d”, &a)
那么些a前边要加&这种了。你不是在攻读程序语言设计,你是在学习如何躲开C的坑。。。可以吗,你说学习C能够领悟底层——你鲜明要在程序语言设计的课程里面来上学计算机底层真的很有含义並且值得坚韧不拔?新人倘若实在要学Computer语言的话,仍旧跟着MIT从python开始吧。不推荐C、不推荐C++、不推荐javascr……余下全文>>
 

简单介绍我们将多个正在运作的主次名叫进程。每一种进程都有它和谐的系统状态,饱含内部存款和储蓄器状态、展开文件…

Python中的并发编制程序

 Threading模块示例
  以threading模块为例,思量那样三个轻巧易行的主题素材:怎么着选取分段并行的秘籍成就四个天数的增进。

 使用示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 from test import ThreadedWorker from queue import Queue   urls_to_process = ["http://facebook.com", "http://pypix.com"]   work_queue = Queue() result_queue = Queue()   def process_url(url):     # TODO: Do some work with the url     return url   def main():     # spawn a pool of threads, and pass them queue instance     for i in range(5):         t = ThreadedWorker(work_queue, result_queue, work_func=process_url)         t.setDaemon(True)         t.start()       # populate queue with data       for url in urls_to_process:         work_queue.put(url)       # wait on the queue until everything has been processed         work_queue.join()       # print results     print(repr(result_queue))   main()

  原作链接: pypix.com   翻译: 伯乐在线 – 熊崽Kevin

  Python提供了一部分很精美的工具用于管理基于线程和经过的面世操作。固然是简轻松单地先后也能够运用那一个工具使得职务并发实行进而加快运转速度。subprocess模块为子进度的创始和通信提供了API。那非常吻合运转与公事相关的顺序,因为那几个API帮忙通过新进度的科鲁班入输出通道传送数据。signal模块将UNIX系统的功率信号量机制暴光给用户,用以在进度之间传递事件新闻。时域信号是异步管理的,平常有能量信号到来时会中断程序当前的行事。能量信号机制能够落到实处粗粒度的新闻传递系统,可是有任何更牢靠的进程内通信技巧能够传递更目眩神摇的新闻。threading模块为出现操作提供了一名目许多高档的,面向对象的API。Thread对象们在二个历程内并发地运维,分享内部存款和储蓄器财富。使用线程能够更加好地扩大I/O密集型的任务。multiprocessing模块同threading模块类似,可是它提供了对于经过的操作。每种进程类是真心诚意的操作系统进度,而且未有分享内部存款和储蓄器能源,但multiprocessing模块提供了经过间分享数据以及传递新闻的建制。平日状态下,将依附线程的次第改为基于进度的比极粗略,只必要修改部分import证明就可以。

from test import ThreadedWorker
from queue import Queue
 
urls_to_process = ["http://facebook.com", "http://pypix.com"]
 
work_queue = Queue()
result_queue = Queue()
 
def process_url(url):
    # TODO: Do some work with the url
    return url
 
def main():
    # spawn a pool of threads, and pass them queue instance 
    for i in range(5):
        t = ThreadedWorker(work_queue, result_queue, work_func=process_url)
        t.setDaemon(True)
        t.start()
 
    # populate queue with data   
    for url in urls_to_process:
        work_queue.put(url)
 
    # wait on the queue until everything has been processed     
    work_queue.join()
 
    # print results
    print(repr(result_queue))
 
main()

在Python中编制程序,怎达成不均等的可能率?

>>> import random
>>> random.random() < 0.7
True
 

  以threading模块为例,思索那样七个简便的标题:怎么着使用分段并行的秘技成功一个天数的增进。

关于Python并发编制程序的学识,本文基本介绍完了,想深远学习Python的相爱的人可以参照他事他说加以考察一下。

 自定义Threading类库

  小编写了三个便于使用threads的袖珍Python类库,包蕴了有些有效的类和函数。

发表评论

电子邮件地址不会被公开。 必填项已用*标注