Python多进程（process）（一）进程和进程池

Python实用教程_spiritx的博客-CSDN博客

在Python中因为有GIL的原因，线程能提供的并发效果并不理想，Python在多核上如果要释放并发的性能，更多的依靠多进程，我们会比线程更深入的去学习多进程。

进程（Process），顾名思义，就是进行中的程序。有一句话说得好：程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体。进程是资源分配的最小单元，也就是说每个进程都有其单独的内存空间。

Unix/Linux系统通过fork系统调用创建一个进程，但是在Windows中并没有fork调用。但是别担心，Python中内置的multiprocessing模块是跨平台的，我们可以通过对multiprocess模块中的Process类进行实例化创建一个进程对象，如：

import os
from multiprocessing import Process

def run_a_sub_proc(name):
    print(f'子进程：{name}（{os.getpid()}）开始...')

if __name__ == '__main__':
    print(f'主进程（{os.getpid()}）开始...')
    # 通过对Process类进行实例化创建一个子进程
    p = Process(target=run_a_sub_proc, args=('测试进程', ))
    p.start()
    p.join()

Process对象

定义：

class multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

进程对象表示在单独进程中运行的活动。

Process 类拥有和 threading.Thread 等价的大部分方法。

应始终使用关键字参数调用构造函数。
group 应该始终是 None ，它仅用于兼容 threading.Thread 。
target 是由 run() 方法调用的可调用对象，可以是一个函数，也可以是一个可调用的函数对象，默认为 None ，None意味着什么都没有被调用。
name 是进程名称。
args 是目标调用的参数元组，元组中的每个元素对应一个函数的参数。
kwargs 是目标调用的关键字参数字典。
daemon 将进程 daemon 标志设置为 True 或 False 。如果是 None （默认值），则该标志将从创建的进程继承。

在默认情况下，不会将任何参数传递给 target。 args 参数默认值为 ()，可被用来指定要传递给 target 的参数列表或元组。

属性和方法

属性和方法名	说明
name	进程的名称。该名称是一个字符串，仅用于识别目的。它没有语义。可以为多个进程指定相同的名称。初始名称由构造器设定。如果没有为构造器提供显式名称，则会构造一个形式为 'Process-N1:N2:...:Nk' 的名称，其中每个 Nk 是其父亲的第 N 个孩子。
run()	Process对象最重要的方法，表示进程活动的方法，可以在子类中重载此方法。
start()	启动进程活动。这个方法每个进程对象最多只能调用一次。它会将对象的 run() 方法安排在一个单独的进程中调用。
join([timeout])	如果可选参数 timeout 是 None （默认值），则该方法将阻塞，直到调用 join() 方法的进程终止。如果 timeout 是一个正数，它最多会阻塞 timeout 秒。请注意，如果进程终止或方法超时，则该方法返回 None 。检查进程的 exitcode 以确定它是否终止。一个进程可以被 join 多次。进程无法join自身，因为这会导致死锁。尝试在启动进程之前join进程是错误的。
is_alive()	返回进程是否还活着。粗略地说，从 start() 方法返回到子进程终止之前，进程对象仍处于活动状态。
daemon	进程的守护标志，一个布尔值。这必须在 start() 被调用之前设置。初始值继承自创建进程。当进程退出时，它会尝试终止其所有守护进程子进程。请注意，不允许在守护进程中创建子进程。这是因为当守护进程由于父进程退出而中断时，其子进程会变成孤儿进程。另外，这些不是 Unix 守护进程或服务，它们是正常进程，如果非守护进程已经退出，它们将被终止（并且不被合并）。
pid	返回进程ID。在生成该进程之前，这将是 `None` 。
exitcode	子进程的退出代码。如果该进程尚未终止则为 None 。如果子进程的 run() 方法正常返回，退出代码将是 0 。如果它通过 sys.exit() 终止，并有一个整数参数 N ，退出代码将是 N 。如果子进程由于在 run() 内的未捕获异常而终止，退出代码将是 1 。如果它是由信号 N 终止的，退出代码将是负值 -N 。
authkey	进程的身份验证密钥（字节字符串）。当 multiprocessing 初始化时，主进程使用 os.urandom() 分配一个随机字符串。当创建 Process 对象时，它将继承其父进程的身份验证密钥，可以通过将 authkey 设置为另一个字节字符串来更改。
sentinel	系统对象的数字句柄
terminate()	终止进程，在UNIX系统中，使用SIGTERM进行终止，在windows系统，调用TerminateProcess进行终止，请注意，进程的后代进程将不会被终止 —— 它们将简单地变成孤立的。
kill()	在UNIX系统中，使用SIGTERM终止进程
close()	关闭 Process 对象，释放与之关联的所有资源。如果底层进程仍在运行，则会引发 ValueError 。一旦 close() 成功返回， Process 对象的大多数其他方法和属性将引发 ValueError 。

注意 start() 、 join() 、 is_alive() 、 terminate() 和 exitcode 方法只能由创建进程对象的进程调用。

子进程的创建

与线程一样，子进程也有两种创建方式，一种是直接使用process对象来拉起一个对象，另外一种是使用process的子类。

通过Process创建子进程

和使用 thread 类创建子线程的方式非常类似，使用 Process 类创建实例化对象，其本质是调用该类的构造方法创建新进程。Process 类的构造方法格式如下：

def __init__(self,group=None,target=None,name=None,args=(),kwargs={})

其中，各个参数的含义为：

group：该参数未进行实现，不需要传参；
target：为新建进程指定执行任务，也就是指定一个函数或者一个可执行对象；
name：为新建进程设置名称；
args：为 target 参数指定的参数传递非关键字参数；
kwargs：为 target 参数指定的参数传递关键字参数。

import os, time
from multiprocessing import Process

URLS=['https://blog.csdn.net/spiritx/article/details/132783171',
      'https://blog.csdn.net/spiritx/article/details/132782806',
      'https://blog.csdn.net/spiritx/article/details/132778558',
      'https://blog.csdn.net/spiritx/article/details/132773698']

def downloadUrl(url, nsecs):
    time.sleep(1)
    print(f'进程ID={os.getpid()}, {__name__=} download: {url}')


# p1 = Process(target=downloadUrl, args=(URLS[0], 3)) #RuntimeError
# p1.start()
# downloadUrl(URLS[1], 4)
# p1.join()

if __name__ == '__main__':
    p1 = Process(target=downloadUrl, args=(URLS[0], 3))
    p2 = Process(target=downloadUrl, args=(URLS[1], 4))
    p1.start()
    p2.start()
    downloadUrl(URLS[3], 4)
    p1.join()
    p2.join()

‘’'
进程ID=64482, __name__='__main__' download: https://blog.csdn.net/spiritx/article/details/132773698
进程ID=64484, __name__='__mp_main__' download: https://blog.csdn.net/spiritx/article/details/132783171
进程ID=64485, __name__='__mp_main__' download: https://blog.csdn.net/spiritx/article/details/132782806
‘''

注意：因为进程和子进程复用同一套代码，一定要写if __name__ == '__main__':这段代码，否则会出现RuntimeError的异常。

从输出来看，子进程和父进程的__name__并不是一个，父进程是__main__，而子进程是__mp_main__

通过Process子类创建子进程

和使用 thread 子类创建线程的方式类似，除了直接使用 Process 类创建进程，还可以通过创建 Process 的子类来创建进程。
需要注意的是，在创建 Process 的子类时，需在子类重写 run() 方法。实际上，该方法所起到的作用，就如同第一种创建方式中 target 参数执行的函数。
另外，通过 Process 子类创建进程，和使用 Process 类一样，先创建该类的实例对象，然后调用 start() 方法启动该进程。下面程序演示如何通过 Process 子类创建一个进程。

import os, time
import multiprocessing

URLS=['https://blog.csdn.net/spiritx/article/details/132783171',
      'https://blog.csdn.net/spiritx/article/details/132782806',
      'https://blog.csdn.net/spiritx/article/details/132778558',
      'https://blog.csdn.net/spiritx/article/details/132773698']


def downloadUrl(url='', secs=1):
    time.sleep(secs)
    print(f'进程ID={os.getpid()}, {__name__=} download: {url}')


class MyChildProcess(multiprocessing.Process):
    def __init__(self, url, secs):
        #super.__init__(self) #TypeError: descriptor '__init__' requires a 'super' object but received a 'MyChildProcess'
        multiprocessing.Process.__init__(self)
        self.url = url
        self.secs = secs

    def run(self):
        downloadUrl(self.url, self.secs)



if __name__ == '__main__':
    p1 = MyChildProcess(URLS[0], 3)
    p2 = MyChildProcess(URLS[1], 4)
    p1.start()
    p2.start()
    downloadUrl(URLS[3], 4)
    p1.join()
    p2.join()

‘’'
进程ID=65688, __name__='__mp_main__' download: https://blog.csdn.net/spiritx/article/details/132783171
进程ID=65686, __name__='__main__' download: https://blog.csdn.net/spiritx/article/details/132773698
进程ID=65689, __name__='__mp_main__' download: https://blog.csdn.net/spiritx/article/details/132782806
‘''

有几个地方要特别注意：

注意一定要重写__init__()和run()方法，如果不重写__init__()方法，参数要和Process一致。
在子类的__init__()方法中一定要调用Process.__init__()方法，写super.__init__()方法会报TypeError的异常。

进程池

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

class multiprocessing.Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])

processes — 进程池中进程数量，如果为 None，则使用 os.cpu_count() 返回的值
initializer — 如果该参数不为 None，则所有进程池中的进程启动时都会先执行 initializer(*initargs)
maxtasksperchild — 如果该参数不为 None，则进程在执行 maxtasksperchild 次任务后会被自动销毁、重启
context — 用于指定进程池中进程运行的上下文

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程他的任务结束，新的任务会交给这个空闲进程去处理。

import os, time
import multiprocessing
import random

URLS=['https://blog.csdn.net/spiritx/article/details/132783171',
      'https://blog.csdn.net/spiritx/article/details/132782806',
      'https://blog.csdn.net/spiritx/article/details/132778558',
      'https://blog.csdn.net/spiritx/article/details/132773698',
      'https://blog.csdn.net/spiritx/article/details/5',
      'https://blog.csdn.net/spiritx/article/details/6',
      'https://blog.csdn.net/spiritx/article/details/7',
      'https://blog.csdn.net/spiritx/article/details/8',
      'https://blog.csdn.net/spiritx/article/details/9']

INDEXS=[1,2,3,4,5,6,7,8,9]
PARAMS=list(zip(URLS, INDEXS)) #通过zip()方法将多个参数压缩成list对象

def downloadUrl(url, index):
    #url, index = param  # 对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    time.sleep(random.randint(1,3))
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    results = [pool.apply_async(downloadUrl, param) for param in PARAMS]
    pool.close()
    pool.join()

    for result in results:
        print(f'{result.get()=}')

    

‘’'
进程ID=75676, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/132783171',index=1
进程ID=75677, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/132782806',index=2
进程ID=75675, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/132778558',index=3
进程ID=75678, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/132773698',index=4
进程ID=75677, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/132782806',index=2
进程ID=75677, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=75675, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/132778558',index=3
进程ID=75675, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=75678, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/132773698',index=4
进程ID=75678, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=75676, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/132783171',index=1
进程ID=75676, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=75677, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=75677, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=75676, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=75675, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=75678, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=75677, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
result.get()=1
result.get()=2
result.get()=3
result.get()=4
result.get()=5
result.get()=6
result.get()=7
result.get()=8
result.get()=9
‘''

从上面的结果可以看出，75677进程在处理任务结束后，立即就得到了一个新的任务进行处理。

属性和方法

属性和方法名	说明
apply(unc[, args=()[, kwds={}]])	同步执行，很少用。使用 args 参数以及 kwds 命名参数调用 func , 它会返回结果前阻塞。不建议使用，并且3.x以后不再出现
apply_async(func[, args[, kwds[, callback[, error_callback]]]])	异步执行。apply() 方法的一个变种，返回一个 AsyncResult 对象。如果指定了 callback , 它必须是一个接受单个参数的可调用对象。当执行成功时， callback 会被用于处理执行后的返回结果，否则，调用 error_callback 。如果指定了 error_callback , 它必须是一个接受单个参数的可调用对象。当目标函数执行失败时，会将抛出的异常对象作为参数传递给 error_callback 执行。回调函数应该立即执行完成，否则会阻塞负责处理结果的进程。
map(func, iterable[, chunksize])	内置 map() 函数的并行版本。它会保持阻塞直到获得结果。这个方法会将可迭代对象分割为许多块，然后提交给进程池。可以将 chunksize 设置为一个正整数从而（近似）指定每个块的大小可以。注意对于很长的迭代对象，可能消耗很多内存。可以考虑使用 imap() 或 imap_unordered() 并且显式指定 chunksize 以提升效率。
map_async(func, iterable[, chunksize[, callback[, error_callback]]])	map() 方法的一个变种，返回一个 AsyncResult 对象。如果指定了 callback , 它必须是一个接受单个参数的可调用对象。当执行成功时， callback 会被用于处理执行后的返回结果，否则，调用 error_callback 。如果指定了 error_callback , 它必须是一个接受单个参数的可调用对象。当目标函数执行失败时，会将抛出的异常对象作为参数传递给 error_callback 执行。回调函数应该立即执行完成，否则会阻塞负责处理结果的进程。
imap(func, iterable[, chunksize])	map() 的延迟执行版本。 chunksize 参数的作用和 map() 方法的一样。对于很长的迭代器，给 chunksize 设置一个很大的值会比默认值 1 极大地加快执行速度。同样，如果 chunksize 是 1 , 那么 imap() 方法所返回的迭代器的 next() 方法拥有一个可选的 timeout 参数：如果无法在 timeout 秒内执行得到结果，则 next(timeout) 会抛出 multiprocessing.TimeoutError 异常。
imap_unordered(func, iterable[, chunksize])	和 imap() 相同，只不过通过迭代器返回的结果是任意的。（当进程池中只有一个工作进程的时候，返回结果的顺序才能认为是"有序"的）
starmap(func, iterable[, chunksize])	和 map() 类似，不过 iterable 中的每一项会被解包再作为函数参数。比如可迭代对象 [(1,2), (3, 4)] 会转化为等价于 [func(1,2), func(3,4)] 的调用。
starmap_async(func, iterable[, chunksize[, callback[, error_callback]]])	相当于 starmap() 与 map_async() 的结合，迭代 iterable 的每一项，解包作为 func 的参数并执行，返回用于获取结果的对象。
close()	阻止后续任务提交到进程池，当所有任务执行完成后，工作进程会退出。
terminate()	不必等待未完成的任务，立即停止工作进程。当进程池对象被垃圾回收时，会立即调用 terminate()。
join()	等待工作进程结束。调用 join() 前必须先调用 close() 或者 terminate()

进程池提交任务的方法

进程池有多种方式可以提交任务，这里举例说明几种常用的方法。

一般方法apply()和apply_async()

apply(func [，args [，kwds ] ] )

使用参数args和关键字参数kwds调用func。它会阻塞，直到结果准备就绪。鉴于此块，更适合并行执行工作。此外，func 仅在池中的一个工作程序中执行。

import os
from multiprocessing import Pool
import time
def foo(p):
       print(f'进程ID{os.getpid()},{p=}')
       time.sleep(0.1)

if __name__=="__main__":
    pool = Pool(processes=3)
    for i  in range(10):
        pool.apply(foo, args=(i,))
    print('子进程提交完成')
    pool.close()
    pool.join()

‘’'
进程ID69407,p=0
进程ID69406,p=1
进程ID69409,p=2
进程ID69407,p=3
进程ID69406,p=4
进程ID69409,p=5
进程ID69407,p=6
进程ID69406,p=7
进程ID69409,p=8
进程ID69407,p=9
子进程提交完成
‘''

import os
from multiprocessing import Pool
import time
def foo(p):
       print(f'进程ID{os.getpid()} 开始....{p=}')
       time.sleep(0.1)
       print(f'进程ID{os.getpid()} 结束.{p=}')

if __name__=="__main__":
    pool = Pool(processes=3)
    for i  in range(10):
        pool.apply(foo, args=(i,))   #维持执行的进程总数为10，当一个进程执行完后启动一个新进程.
        print(f'进程{i}启动...')

    print('子进程提交完成')
    pool.close()
    pool.join()

‘’'
进程ID69541 开始....p=0
进程ID69541 结束.p=0
进程0启动...
进程ID69542 开始....p=1
进程ID69542 结束.p=1
进程1启动...
进程ID69543 开始....p=2
进程ID69543 结束.p=2
进程2启动...
进程ID69541 开始....p=3
进程ID69541 结束.p=3
进程3启动...
进程ID69542 开始....p=4
进程ID69542 结束.p=4
进程4启动...
进程ID69543 开始....p=5
进程ID69543 结束.p=5
进程5启动...
进程ID69541 开始....p=6
进程ID69541 结束.p=6
进程6启动...
进程ID69542 开始....p=7
进程ID69542 结束.p=7
进程7启动...
进程ID69543 开始....p=8
进程ID69543 结束.p=8
进程8启动...
进程ID69541 开始....p=9
进程ID69541 结束.p=9
进程9启动...
子进程提交完成
‘''

从上面的例子可以看到，apply()是顺序启动进程的，在被启动的进程执行完后，再启动下一个进程，实际是没有任何并发执行。

apply_async(func[, args[, kwds[, callback[, error_callback]]]])

异步进程池（非阻塞）,返回结果对象的方法的变体。如果指定了回调，则它应该是可调用的，它接受单个参数。当结果变为就绪时，将对其应用回调，即除非调用失败，在这种情况下将应用error_callback。如果指定了error_callback，那么它应该是一个可调用的，它接受一个参数。如果目标函数失败，则使用异常实例调用error_callback。回调应立即完成，否则处理结果的线程将被阻止。

import os
from multiprocessing import Pool
import time
def foo(p):
       print(f'进程ID{os.getpid()} 开始....{p=}')
       time.sleep(0.1)
       print(f'进程ID{os.getpid()} 结束.{p=}')

if __name__=="__main__":
    pool = Pool(processes=3)
    for i  in range(10):
        pool.apply_async(foo, args=(i,))   
        print(f'进程{i}启动...')

    print('子进程提交完成')
    pool.close()
    pool.join()

’’’
进程0启动...
进程1启动...
进程2启动...
进程3启动...
进程4启动...
进程5启动...
进程6启动...
进程7启动...
进程8启动...
进程9启动...
子进程提交完成
进程ID69599 开始....p=0
进程ID69598 开始....p=1
进程ID69600 开始....p=2
进程ID69599 结束.p=0
进程ID69599 开始....p=3
进程ID69598 结束.p=1
进程ID69598 开始....p=4
进程ID69600 结束.p=2
进程ID69600 开始....p=5
进程ID69599 结束.p=3
进程ID69599 开始....p=6
进程ID69598 结束.p=4
进程ID69598 开始....p=7
进程ID69600 结束.p=5
进程ID69600 开始....p=8
进程ID69599 结束.p=6
进程ID69599 开始....p=9
进程ID69598 结束.p=7
进程ID69600 结束.p=8
进程ID69599 结束.p=9
‘’‘

从上面的例子可以看到，apply_async()是异步启动的，子进程还未完全启动，apply_async()就已经返回。

AsyncResult对象

AsyncResult是Pool.apply_async() 和 Pool.map_async() 返回的对象所属的类。

主要方法有

方法	说明
get([timeout])	用于获取执行结果。如果 timeout 不是 None 并且在 timeout 秒内仍然没有执行完得到结果，则抛出 multiprocessing.TimeoutError 异常。如果远程调用发生异常，这个异常会通过 get() 重新抛出。
wait([timeout])	阻塞，直到返回结果，或者 timeout 秒后超时。
ready()	返回执行状态，是否已经完成。
successful()	判断调用是否已经完成并且未引发异常。如果还未获得结果则将引发 ValueError。

import os, time
import multiprocessing

URLS=['https://blog.csdn.net/spiritx/article/details/132783171',
      'https://blog.csdn.net/spiritx/article/details/132782806',
      'https://blog.csdn.net/spiritx/article/details/132778558',
      'https://blog.csdn.net/spiritx/article/details/132773698']

def downloadUrl(url, nsecs):
    time.sleep(1)
    print(f'进程ID={os.getpid()}, {__name__=} download: {url}')
    return os.getpid()


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    results = [pool.apply_async(downloadUrl, (url, 3)) for url in URLS]
    pool.close()
    pool.join()

    for result in results:
        print(f'{result.get()=}')

‘’'
进程ID=72390, __name__='__mp_main__' download: https://blog.csdn.net/spiritx/article/details/132783171
进程ID=72391, __name__='__mp_main__' download: https://blog.csdn.net/spiritx/article/details/132778558
进程ID=72392, __name__='__mp_main__' download: https://blog.csdn.net/spiritx/article/details/132782806
进程ID=72393, __name__='__mp_main__' download: https://blog.csdn.net/spiritx/article/details/132773698
result.get()=72390
result.get()=72392
result.get()=72391
result.get()=72393
‘''

多个参数的可调用对象

apply()和apply_async()支持多参数的可调用对象，但是在传入参数的时候，需要将多个参数封装为tuple进行传入，apply()和apply_async()会自动解包传给可调用对象。

如下：

import os, time
import multiprocessing
import random

URLS=['https://blog.csdn.net/spiritx/article/details/132783171',
      'https://blog.csdn.net/spiritx/article/details/132782806',
      'https://blog.csdn.net/spiritx/article/details/132778558',
      'https://blog.csdn.net/spiritx/article/details/132773698']

INDEXS=[1,2,3,4,5,6,7,8,9]
PARAMS=list(zip(URLS, INDEXS)) #通过zip()方法将多个参数压缩成list对象

def downloadUrl(url, index): #使用*param也是可以的，需要在函数里解包
    #url, index = param  # 对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    time.sleep(random.randint(1,3))
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    results = [pool.apply_async(downloadUrl, param) for param in PARAMS]
    pool.close()
    pool.join()

    for result in results:
        print(f'{result.get()=}')



’’’
进程ID=72786, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/132783171',index=1
进程ID=72785, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/132782806',index=2
进程ID=72784, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/132778558',index=3
进程ID=72787, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/132773698',index=4
进程ID=72787, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/132773698',index=4
进程ID=72786, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/132783171',index=1
进程ID=72785, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/132782806',index=2
进程ID=72784, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/132778558',index=3
result.get()=1
result.get()=2
result.get()=3
result.get()=4
‘''

注意：apply_async的可调用对象接收的是多个参数。

map()和map_async()

内置 map() 函数的并行版本。它会保持阻塞直到获得结果。

map(func, iterable[, chunksize])

这个方法会将可迭代对象分割为许多块，然后提交给进程池。可以将 chunksize 设置为一个正整数从而（近似）指定每个块的大小可以。

注意，map()和map_async()的可调用对象不支持多个参数，需要将多参数包装为tuple，或者使用starmap()和starmap_async()。

import os, time
import multiprocessing
import random

URLS=['https://blog.csdn.net/spiritx/article/details/1',
      'https://blog.csdn.net/spiritx/article/details/2',
      'https://blog.csdn.net/spiritx/article/details/3',
      'https://blog.csdn.net/spiritx/article/details/4',
      'https://blog.csdn.net/spiritx/article/details/5',
      'https://blog.csdn.net/spiritx/article/details/6',
      'https://blog.csdn.net/spiritx/article/details/7',
      'https://blog.csdn.net/spiritx/article/details/8',
      'https://blog.csdn.net/spiritx/article/details/9']

INDEXS=[1,2,3,4,5,6,7,8,9]
PARAMS=list(zip(URLS, INDEXS)) #通过zip()方法将多个参数压缩成list对象

def downloadUrl(param): #不能接受多个参数
    url,index = param #对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    time.sleep(random.randint(1,3))
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    pool.map(downloadUrl, PARAMS)
    print('pool.map submit ok.')
    pool.close()
    pool.join()



‘’'
进程ID=72929, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=72930, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=72932, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=72931, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=72929, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=72929, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=72930, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=72930, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=72930, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=72929, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/5',index=5

进程ID=72930, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=72929, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=72932, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=72932, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=72931, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=72929, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=72930, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=72932, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
pool.map submit ok.
‘''

从上面的输出可以看出，pool.map submit ok是在最后输出的，start download是按顺序输出的，但end download没有按顺序输出，说明：

pool.map是按顺序启动的子进程
子进程是并行执行的
主进程在子进程执行完后，才会执行map之后的代码。

map_async(func, iterable[, chunksize[, callback[, error_callback]]])

map_async()是map() 方法的一个变种，返回一个 AsyncResult 对象。
如果指定了 callback , 它必须是一个接受单个参数的可调用对象。当执行成功时， callback 会被用于处理执行后的返回结果，否则，调用 error_callback 。
如果指定了 error_callback , 它必须是一个接受单个参数的可调用对象。当目标函数执行失败时，会将抛出的异常对象作为参数传递给 error_callback 执行。
回调函数应该立即执行完成，否则会阻塞负责处理结果的进程。

import os, time
import multiprocessing
import random

URLS = ['https://blog.csdn.net/spiritx/article/details/1',
        'https://blog.csdn.net/spiritx/article/details/2',
        'https://blog.csdn.net/spiritx/article/details/3',
        'https://blog.csdn.net/spiritx/article/details/4',
        'https://blog.csdn.net/spiritx/article/details/5',
        'https://blog.csdn.net/spiritx/article/details/6',
        'https://blog.csdn.net/spiritx/article/details/7',
        'https://blog.csdn.net/spiritx/article/details/8',
        'https://blog.csdn.net/spiritx/article/details/9']

INDEXS = [1, 2, 3, 4, 5, 6, 7, 8, 9]
PARAMS = list(zip(URLS, INDEXS))  # 通过zip()方法将多个参数压缩成list对象


def downloadUrl(param):  # 只支持一个参数
    url, index = param  # 对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    time.sleep(random.randint(1, 3))
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    pool.map_async(downloadUrl, PARAMS)
    print('pool.map submit ok.')
    pool.close()
    pool.join()


‘’'
pool.map submit ok.
进程ID=73087, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73088, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73089, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73090, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73087, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73087, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=73088, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73088, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73089, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73089, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73087, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=73087, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73090, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73090, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73087, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73088, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73089, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73090, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
‘''

从上面的例子可以看出，pool.map submit打印在最前面，start download是顺序启动的：

map_async在启动子进程时，不等子进程执行完，立即就执行主进程后面的语句
子进程是按序启动的，并且都是并发的
子进程与主进程也是并发的

imap()和imap_unordered()

imap(func, iterable[, chunksize])

map() 的延迟执行版本。
chunksize 参数的作用和 map() 方法的一样。对于很长的迭代器，给 chunksize 设置一个很大的值会比默认值 1 极大地加快执行速度。
同样，如果 chunksize 是 1 , 那么 imap() 方法所返回的迭代器的 next() 方法拥有一个可选的 timeout 参数：如果无法在 timeout 秒内执行得到结果，则 next(timeout) 会抛出 multiprocessing.TimeoutError 异常。

所谓延迟执行版本，就是并不是所有的子进程都执行完了，才能获得结果，可以在部分进程执行完后，就拿到结果。

下面是map()与imap()拿结果的对比

map版本：

import os, time
import multiprocessing
import random

URLS = ['https://blog.csdn.net/spiritx/article/details/1',
        'https://blog.csdn.net/spiritx/article/details/2',
        'https://blog.csdn.net/spiritx/article/details/3',
        'https://blog.csdn.net/spiritx/article/details/4',
        'https://blog.csdn.net/spiritx/article/details/5',
        'https://blog.csdn.net/spiritx/article/details/6',
        'https://blog.csdn.net/spiritx/article/details/7',
        'https://blog.csdn.net/spiritx/article/details/8',
        'https://blog.csdn.net/spiritx/article/details/9']

INDEXS = [1, 2, 3, 4, 5, 6, 7, 8, 9]
PARAMS = list(zip(URLS, INDEXS))  # 通过zip()方法将多个参数压缩成list对象


def downloadUrl(param):  # 只支持一个参数
    url, index = param  # 对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    #time.sleep(random.randint(1, 3))
    time.sleep(9 - index)
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return 'result:', index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    its = pool.map(downloadUrl, PARAMS)
    print('pool.map submit ok.')
    for it in its:
        print(it)
    pool.close()
    pool.join()

‘’’
进程ID=73691, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73693, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73690, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73692, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73692, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73692, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=73690, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73690, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73693, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73693, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73691, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73691, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73691, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73691, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73691, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73693, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73690, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73692, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
pool.map submit ok.
('result:', 1)
('result:', 2)
('result:', 3)
('result:', 4)
('result:', 5)
('result:', 6)
('result:', 7)
('result:', 8)
('result:', 9)
’‘’

map()版本的返回值都是要在所有进程都执行完后才能获得。

imap()版本：

import os, time
import multiprocessing
import random

URLS = ['https://blog.csdn.net/spiritx/article/details/1',
        'https://blog.csdn.net/spiritx/article/details/2',
        'https://blog.csdn.net/spiritx/article/details/3',
        'https://blog.csdn.net/spiritx/article/details/4',
        'https://blog.csdn.net/spiritx/article/details/5',
        'https://blog.csdn.net/spiritx/article/details/6',
        'https://blog.csdn.net/spiritx/article/details/7',
        'https://blog.csdn.net/spiritx/article/details/8',
        'https://blog.csdn.net/spiritx/article/details/9']

INDEXS = [1, 2, 3, 4, 5, 6, 7, 8, 9]
PARAMS = list(zip(URLS, INDEXS))  # 通过zip()方法将多个参数压缩成list对象


def downloadUrl(param):  # 只支持一个参数
    url, index = param  # 对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    #time.sleep(random.randint(1, 3))
    time.sleep(9 - index)
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return 'result:', index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    its = pool.imap(downloadUrl, PARAMS)
    print('pool.map submit ok.')
    for it in its:
        print(it)
    pool.close()
    pool.join()

‘’'
pool.map submit ok.
进程ID=73772, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73773, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73776, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73775, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73775, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73775, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=73776, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73776, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73773, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73773, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73772, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73772, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
('result:', 1)
('result:', 2)
('result:', 3)
('result:', 4)
进程ID=73772, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73772, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73772, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73773, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73776, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73775, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
('result:', 5)
('result:', 6)
('result:', 7)
('result:', 8)
('result:', 9)
‘''

pool.map submit在首行就打印出来，说明imap的子进程与父进程也是并行执行的。

结果数据打印夹杂在子进程输出的结果打印中，是在一项任务执行完后打印出来。但仍可以看出来，结果数据是按任务的进入顺序打印的。（为了演示，我们实际的任务执行时间是，越早提交的任务运行的时间越长。）

imap_unordered(func, iterable[, chunksize])

和 imap() 相同，只不过通过迭代器返回的结果是任意的。（当进程池中只有一个工作进程的时候，返回结果的顺序才能认为是"有序"的）

import os, time
import multiprocessing
import random

URLS = ['https://blog.csdn.net/spiritx/article/details/1',
        'https://blog.csdn.net/spiritx/article/details/2',
        'https://blog.csdn.net/spiritx/article/details/3',
        'https://blog.csdn.net/spiritx/article/details/4',
        'https://blog.csdn.net/spiritx/article/details/5',
        'https://blog.csdn.net/spiritx/article/details/6',
        'https://blog.csdn.net/spiritx/article/details/7',
        'https://blog.csdn.net/spiritx/article/details/8',
        'https://blog.csdn.net/spiritx/article/details/9']

INDEXS = [1, 2, 3, 4, 5, 6, 7, 8, 9]
PARAMS = list(zip(URLS, INDEXS))  # 通过zip()方法将多个参数压缩成list对象


def downloadUrl(param):  # 只支持一个参数
    url, index = param  # 对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    #time.sleep(random.randint(1, 3))
    time.sleep(9 - index)
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return 'result:', index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    its = pool.imap_unordered(downloadUrl, PARAMS)
    print('pool.map submit ok.')
    for it in its:
        print(it)
    pool.close()
    pool.join()

‘’’
pool.map submit ok.
进程ID=73862, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73864, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73863, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73865, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73865, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73865, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
('result:', 4)
进程ID=73863, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73863, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
('result:', 3)
进程ID=73864, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73864, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
('result:', 2)
进程ID=73862, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73862, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
('result:', 1)
进程ID=73862, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73862, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73862, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
('result:', 8)
('result:', 9)
进程ID=73864, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
('result:', 7)
进程ID=73863, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
('result:', 6)
进程ID=73865, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
('result:', 5)
’‘’

imap_unordered()与imap()几乎一样，只是结果数据是谁先完成谁就能先获得。

starmap()和starmap_async()

map()和map_async()不能支持多参数的可调用对象，starmap()和starmap_async()看上去就像是打的补丁，让他们可以支持多参数的可调用对象。

starmap(func, iterable[, chunksize])
和 map() 类似，不过 iterable 中的每一项会被解包再作为函数参数。
比如可迭代对象 [(1,2), (3, 4)] 会转化为等价于 [func(1,2), func(3,4)] 的调用。

import os, time
import multiprocessing
import random

URLS=['https://blog.csdn.net/spiritx/article/details/1',
      'https://blog.csdn.net/spiritx/article/details/2',
      'https://blog.csdn.net/spiritx/article/details/3',
      'https://blog.csdn.net/spiritx/article/details/4',
      'https://blog.csdn.net/spiritx/article/details/5',
      'https://blog.csdn.net/spiritx/article/details/6',
      'https://blog.csdn.net/spiritx/article/details/7',
      'https://blog.csdn.net/spiritx/article/details/8',
      'https://blog.csdn.net/spiritx/article/details/9']

INDEXS=[1,2,3,4,5,6,7,8,9]
PARAMS=list(zip(URLS, INDEXS)) #通过zip()方法将多个参数压缩成list对象

def downloadUrl(url, index): #可以支持多个参数
    #url,index = param #对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    time.sleep(random.randint(1,3))
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    pool.starmap(downloadUrl, PARAMS)
    print('pool.map submit ok.')
    pool.close()
    pool.join()

‘’'
进程ID=73960, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73962, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73961, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73963, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73960, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73960, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=73962, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73962, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73961, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73961, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73960, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=73960, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73963, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73963, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73962, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73961, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73963, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73960, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
pool.map submit ok.

‘''

starmap_async(func, iterable[, chunksize[, callback[, error_callback]]])
相当于 starmap() 与 map_async() 的结合，迭代 iterable 的每一项，解包作为 func 的参数并执行，返回用于获取结果的对象。

import os, time
import multiprocessing
import random

URLS = ['https://blog.csdn.net/spiritx/article/details/1',
        'https://blog.csdn.net/spiritx/article/details/2',
        'https://blog.csdn.net/spiritx/article/details/3',
        'https://blog.csdn.net/spiritx/article/details/4',
        'https://blog.csdn.net/spiritx/article/details/5',
        'https://blog.csdn.net/spiritx/article/details/6',
        'https://blog.csdn.net/spiritx/article/details/7',
        'https://blog.csdn.net/spiritx/article/details/8',
        'https://blog.csdn.net/spiritx/article/details/9']

INDEXS = [1, 2, 3, 4, 5, 6, 7, 8, 9]
PARAMS = list(zip(URLS, INDEXS))  # 通过zip()方法将多个参数压缩成list对象


def downloadUrl(url, index):  # 只支持一个参数
    #url, index = param  # 对多个参数进行解包
    print(f'进程ID={os.getpid()}, {__name__=} start download: {url=},{index=}')
    time.sleep(random.randint(1, 3))
    print(f'进程ID={os.getpid()}, {__name__=} end download: {url=},{index=}')
    return index


if __name__ == '__main__':
    pool = multiprocessing.Pool(4)
    pool.starmap_async(downloadUrl, PARAMS)
    print('pool.map submit ok.')
    pool.close()
    pool.join()

‘’'
pool.map submit ok.
进程ID=73991, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73990, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73993, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73992, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73993, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/3',index=3
进程ID=73993, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=73992, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/4',index=4
进程ID=73992, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73991, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/1',index=1
进程ID=73991, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73990, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/2',index=2
进程ID=73990, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73993, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/5',index=5
进程ID=73993, __name__='__mp_main__' start download: url='https://blog.csdn.net/spiritx/article/details/9',index=9
进程ID=73991, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/7',index=7
进程ID=73992, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/6',index=6
进程ID=73990, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/8',index=8
进程ID=73993, __name__='__mp_main__' end download: url='https://blog.csdn.net/spiritx/article/details/9',index=9

‘''

你可能感兴趣的:(python,开发语言)

Python实现的空中作战模拟器 - 探索无限可能性明俪钧
Python实现的空中作战模拟器-探索无限可能性该项目是一个基于Python语言的空中作战模拟器，旨在提供一个互动的学习和娱乐环境，让用户通过编程的方式理解飞行战术、策略规划以及游戏开发的基本原理。技术分析编程语言：PythonPython以其简洁明了的语法和丰富的库资源而受到广大开发者喜爱，这使得它成为快速原型设计和教育项目的理想选择。在这个模拟器中，Python被用来处理游戏逻辑、渲染图形界面
Windows 下 python 版本快速切换（全干货，无一句废话！！！）我是懒洋洋大王 Python探索之旅 python 开发语言
前言：安装新版本PythonPython环境安装与配置（Windows环境）这里参考我的另一篇博客，本文主要是讲如何实现python版本快速切换1.查看当前python默认版本使用命令，可以发现当前默认运行的Python版本python-–version例图如下：2.修改环境变量重要，重要，重要！！！：在cmd下输入python打开的python程序的版本，取决于环境变量里哪个版本的python路
Python文件打包成exe文件 ybb_ymm Python python 开发语言
文章目录背景安装pyinstaller开始打包总结背景今天因为在线将pdf转为word被收费了，有点不爽，所以自己动手撸一个pdf转word的小工具，想着打包成exe给朋友使用，万一哪天会用到呢？安装pyinstaller打开cmd命令窗口或者是在PyCharm工具的Terminal中执行如下命令pipinstallpyinstaller如果遇到超时问题socket.timeout:Theread
爬虫代理IP池的实现小温侯
代理池的思路之前写过一篇关于代理的文档：爬虫和IP代理，里面介绍了一些代理的基本知识，后半部分我也见到那说了下如何用Python抓取免费的代理IP并检验其有效性。这篇文章就是在其基础上尝试完整实现了一个代理IP池：后端用的是sqlite3，因为之前爬网易云音乐评论时后端就是用的它，最后存了大概一万条评论，读取写入时间都很不错，我估计代理池里的IP最后也只会是这个量级。还有就是sqlite3用起来非
C语言贪吃蛇(坤)(全解注释-手把手教会) ZARD996 c语言数据结构
00简介:0.1:演示:0.2:游戏说明:玩家通过右方的方向键和加速键来控制贪吃坤吃到随机刷新的篮球来尽可能增长贪吃坤的体长,增加分数。1.项目说明:1.1项目主题:本项目的主题是创建一个基于C语言的贪吃蛇游戏，运用双向循环链表来管理蛇的身体节点，实现蛇体的灵活移动。同时，通过碰撞检测机制，让蛇在游戏中与食物、墙壁及自身进行互动，实现游戏的核心逻辑。1.2技术实现:项目采用C语言作为开发语言，整个
Python数据结构：元组详解（创建、访问、不可变特性）做梦都在改BUG python 数据结构开发语言学习
Python中的元组（Tuple）是一种重要的数据结构，与列表类似，但元组是不可变的，这意味着一旦创建，就无法修改。元组的不可变性使其在某些场景下比列表更具优势。本文将详细介绍Python元组的创建、访问、不可变特性，并附上一个综合复杂的例子，全面展示元组在实际编程中的应用。一、创建元组元组的创建非常简单，使用圆括号()将多个元素包裹起来。元组可以包含任意类型的元素，包括数字、字符串、布尔值、甚至
pythongui 三维_PyQt5嵌入mayavi-python显示三维实体 weixin_39565910 pythongui 三维
#First,andbeforeimportinganyEnthoughtpackages,settheETS_TOOLKIT#environmentvariabletoqt4,totellTraitsthatwewilluseQt.importos#os.environ['ETS_TOOLKIT']='qt4'#Bydefault,thePySidebindingwillbeused.Ifyou
python元组有什么用_python元组是什么意思 weixin_39895881 python元组有什么用
python元组(tuple)是一个不可变的序列。Python元组和Python列表数据类似，都是线性表。唯一不同的是，Python元组赋值后所存储的数据不能被程序修改，可以将元组看作是只能读取数据不能修改数据的列表。Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。如下实例：实例(Python
Python 异步编程介绍与代码示例大霸王龙 python 网络服务器异步编程
Python异步编程介绍与代码示例一、异步编程概述异步编程是一种编程范式，它旨在处理那些需要等待I/O操作完成或执行耗时任务的情况。在传统的同步编程中，代码会按照顺序逐行执行，直到遇到一个耗时操作，它会阻塞程序的执行直到该操作完成。这种阻塞式的模型在某些场景下效率低下，因为代码在等待操作完成时无法执行其他任务。异步编程通过非阻塞I/O和协程（coroutine）来提高效率，使得程序在等待某些操作时
Python异步编程_asyncio 代码输入中... python 开发语言深度学习 numpy
1.协程协程不是计算机提供的，它是程序员创造的。协程-Co_routine，也可以称之为微线程，是一种用户态内的上下文切换技术，简而言之，其实就是通过一个线程实现代码块相互切换执行。实现协程的几种方法：greenlet，早期模块yield关键字asyncio装饰器(python3.4及其之后)async、await关键字(python3.5及其之后)【推荐】1.1greenlet实现协程pip3i
python元组用法 IT技术土狗 python从入门到入狱 python
python元组元组的作用元组与列表类似，也是可以存多个任意类型的元素。不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取在()内用逗号分隔开多个任意类型的值>>>filed=("云南","贵州","西藏")#本质:filed=("云南","贵州","西藏")#>>>filed('云南','贵州','西藏')>>>type(filed)强调：如果元
Python 协程 & 异步编程 (asyncio) 入门介绍 linmeiyun 后端 python python 爬虫学习开发语言机器学习
在近期的编码工作过程中遇到了async和await装饰的函数，查询资料后了解到这种函数是基于协程的异步函数。这类编程方式称为异步编程，常用在IO较频繁的系统中，如：Tornadoweb框架、文件下载、网络爬虫等应用。协程能够在IO等待时间就去切换执行其他任务，当IO操作结束后再自动回调，那么就会大大节省资源并提供性能。接下来便简单的讲解一下异步编程相关概念以及案例演示。1.协程简介1.1协程的含义
Linux中检查网络问题的常用命令程序员喵哥 Linux 网络 linux php 服务器运维
更多Python学习内容：ipengtao.com在Linux系统中，网络问题是常见的挑战之一。无论是服务器管理员还是普通用户，都可能遇到各种网络故障，如连接问题、DNS解析问题、网络延迟等。为了快速诊断和解决这些问题，掌握一些常用的网络故障排查命令是至关重要的。本文将介绍一些在Linux系统中常用的网络故障排查命令，并提供详细的示例代码，方便更好地理解和应用这些命令。ping命令ping命令是最
将 python 文件打包为exe文件 hylreg python 开发语言
可以使用PyInstaller来将Python文件打包为可执行的.exe文件。以下是基本的步骤：安装PyInstaller：pipinstallpyinstaller打包Python文件：在终端中运行以下命令：pyinstaller--onefileyour_script.py–onefile选项将所有文件打包到一个.exe文件中。找到输出文件：打包完成后，.exe文件通常会在dist目录中找到。
Django1.8无法连接mysql的问题Did you install mysqlclient or MySQL-python 纵横千里，捭阖四方 python mysql 数据库 database
使用Django1.8创建新项目时，经常出现一个奇怪的问题ErrorloadingMySQLdbModule'DidyouinstallmysqlclientorMySQL-python?'即使将这两个使用pipinstall给安装了还是无法启动，这时候应该做的是：pipinstallpymysql然后在工程目录下的__init__.py文件里添加importpymysqlpymysql.inst
python连接oracle数据库报DPI-1047: Cannot locate a 64-bit Oracle Client library 没有星期八~ 数据库 python oracle
pthon版本和oracle客户端版本一致即可，即都为64位或都为32位importcx_Oracleimportsysimportostry:ifsys.platform.startswith("darwin"):lib_dir=os.path.join(os.environ.get("HOME"),"Downloads","instantclient_19_21")cx_Oracle.init
Node.js的学习与简单使用学习Java的唐唐前端技术学习 java js nodejs
一、简介1、什么是Node.js简单的说Node.js就是运行在服务端的JavaScript。Node.js是一个事件驱动I/O服务端JavaScript环境，基于Google的V8引擎，V8引擎执行Javascript的速度非常快，性能非常好。2、Node.js有什么用如果你是一个前端程序员，你不懂得像PHP、Python或Ruby等动态编程语言，然后你想创建自己的服务，那么Node.js是一个
cx_Oracle.DatabaseError: DPI-1047: Cannot locate a 64-bit Oracle Client library 虚幻如影 python oracle 数据库 python
pipinstallcx_Oracleimportcx_Oracle再导入该模块进行数据库连接的时候报错这个错误表明您的Python环境是64位的，但是您尝试使用的Oracle客户端库（oci.dll）是32位的根据官方给出的文档进行查看cx_Oracle8Installation—cx_Oracle8.3.0documentationhttps://cx-oracle.readthedocs.i
python爬取上市公司年报信息_python3爬取巨潮资讯网的年报数据 Tsy.H
需要用到的库：importrequestsimportrandom#随机生成爬虫休眠时间importtime前期准备：巨潮资讯网有反爬虫机制，所以先打开巨潮资讯网的年报板块，看看有什么解决办法。巨潮咨询年报板块网页向服务器发送的数据请求可以通过这样的方式获取单页年报的数据，数据格式为json。其中包括年报名称，地址等数据。所以思路就是，先通过单页的数据，然后在对每页中的年报数据进行下载。完整代码：
python下载numpy库_python怎么下载numpy weixin_39977276 python下载numpy库
安装Pythonstep1：官网下载安装包；https://www.python.org/我下载的是python-3.4.4.msistep2：python环境变量配置；计算机-属性-高级系统设置-环境变量-系统变量找到PATH，点击编辑，加英文分号;在分号后面加上python.exe所在的路径，点击确定。step3：python安装验证W+R运行cmd，打开终端，输入：python显示版本信息表
django 不用自带的mysql_Python MySQL 数据库连接 (三) mysqlclient django默认使用许菲比 django 不用自带的mysql
Mysql驱动介绍MySQL-python(弃用)：也就是MySQLdb，是对C语言操作MySQL数据库的一个简单封装。遵循了PythonDBAPIv2。但是只支持Python2，目前还不支持Python3。mysqlclient(安装难,但django官方默认)：是MySQL-python的另外一个分支，支持Python3并且修复了一些bug。pymysql：纯Python实现的一个驱动，因为是
xc_oracle 1047 error,Error: DPI-1047: Cannot locate a 64-bit Oracle Client library: "问题 Oli Zhao xc_oracle 1047 error
参考：python打包后，在别的机器遇上运行，提示报错，报错内容为：Error:DPI-1047:Cannotlocatea64-bitOracleClientlibrary:"Thespecifiedmodulecouldnotbefound".Seeforhelp根本问题：打包时未将oracledll文件打包进去，导致运行找不到链接库。临时解决办法：方法一：1、安装oracle64位客户端2、
cx_Oracle 错误.DPI-1047:找不到 64 位 Oracle 客户端库潮易 oracle 数据库
在Python中使用cx_Oracle模块与Oracle数据库进行交互时，如果遇到“DPI-1047:找不到64位Oracle客户端库”错误，通常是因为系统无法找到适合当前环境（操作系统、位数）的Oracle客户端库。解决这个问题的步骤大致如下：###1.安装对应版本的OracleInstantClient-**下载**：首先，根据你的操作系统类型（如Windows、macOS、Linux等）和位
Python日志模块详解 WineMonk Python python logging
Python日志模块详解Python的日志模块（logging）是一个非常强大、灵活的日志记录框架，适用于各种规模的应用程序。它允许开发者将程序执行中的信息输出到多个地方，如控制台、文件、网络等。接下来我们来详细介绍它的功能和使用方法。1.基本概念1.1日志级别logging模块提供了几种内置的日志级别，用于标识日志的严重程度。默认情况下，日志级别从低到高依次为：DEBUG：调试信息，最详细的日志
Python是什么？Python能干什么？一篇文章让你对Python了如指掌！！武昌库里写JAVA 面试题汇总与解析 spring log4j java 开发语言算法
Python作为当下最热门的编程语言，已经成为了多个领域的首选语言。能用到Python的地方非常多。从入门级小白到专业级的大佬，数据挖掘、科学计算、图像处理、人工智能，Python都可以胜任。或许是因为这种万能属性，现在有很多的小伙伴都开始学习Python。而现在Python的火爆甚至已经来到了程序员的圈子外，进入了国务院《新一代人工智能发展规划的通知》里。Python也已经走进了小学生的课程里，
关于Python错误提示蔚来天空
程序错误提示在学习语言时不仅要学习语言的语法,更要认识语言,认识错误及找到解决错误的方法找bug,很快乐;bug让我的生活充满了无尽的乐趣...嘿嘿嘿写bug,很快乐修完bug,是不存在的当然,我们要记住以下单词,让你头疼但又不得不接受的''程序员的英文爱情宣誓''Error:当你在执行程序时,突然这个词一个''闪现''到你眼前,不知道你内心会有多少'XX'灰奔而过,记好了,记好了,记好了,都拿本
Python数据类型长度的可变与不可变以及对Python的认识 Vision啊 1024程序员节
一、在Python中，有些数据类型是长度不可变的，有些是长度可变的。下面是常见的数据类型及其可变性：1、长度不可变的数据类型：数字（int、float、complex）布尔值（bool）字符串（str）元组（tuple）2、长度可变的数据类型：列表（list）集合（set）字典（dict）3、这些数据类型的定义方法如下：int：整数类型，例如x=42。float：浮点数类型，例如y=3.14。co
Python青少年简明教程：模块学习&实践爱好者青少年编程入门系列 Python学习 python 开发语言
Python青少年简明教程：模块Python模块是一种组织代码的方式，用于将相关的函数、类和变量分组在一起，从而提高代码的可重用性和可维护性。一个模块通常是一个包含Python代码的文件，文件名以.py作为扩展名。使用模块，可以在不同的Python脚本之间共享代码，而不需要重复编写相同的代码。概述Python模块可以分为以下几类：内置模块Python标准库中自带的模块，如math、os、sys、t
Python青少年简明教程：文件处理学习&实践爱好者青少年编程入门系列 Python学习 python 开发语言
Python青少年简明教程：文件处理计算机科学中的文件是指存储在计算机存储设备上的数据集合。这些数据可以是程序代码、文本、图像、音频、视频等各种形式的信息。在计算机科学中，文件通常被分为两类：文本文件和二进制文件。每个文件都有一个唯一的文件名，用于标识该文件。文件名通常由两个部分组成：名字和扩展名（例如，document.txt中，document是名字，.txt是扩展名）。文件路径（FilePa
python界面开发 - filedialog 文件选择对话框牛魔王的小怪兽 python python 前端
文章目录1.Tkinter开发2.filedialog文件选择对话框3.python图形界面开发3.1.Python图形界面开发——Tkinter3.2.Python图形界面开发——PyQt3.3.Python图形界面开发——wxPython3.4.Python图形界面开发——PyGTK：基于GTK3.5.Python图形界面开发——Kivy3.6.Python图形界面开发——可视化工具3.7.P
插入表主键冲突做更新 a-john
有以下场景：用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。问题：如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。解决： mysql中提供了一个sql语
Android xml资源文件中@、@android:type、@*、？、@+含义和区别 Cb123456 @+@?@*
一.@代表引用资源 1.引用自定义资源。格式：@[package:]type/name android：text="@string/hello" 2.引用系统资源。格式：@android:type/name android:textColor="@android:color/opaque_red"
数据结构的基本介绍天子之骄数据结构散列表树、图线性结构价格标签
数据结构的基本介绍数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。经典的数据结构大致如下：一：线性数据结构 (1)：列表 a
通过二维码开放平台的API快速生成二维码一炮送你回车库 api
现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。 html代码如下:(二维码将生成在这div下) ? 1 &nbs
ImageIO读取一张图片改变大小 3213213333332132 java IO image BufferedImage
package com.demo; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imageio.ImageIO; /** * @Description 读取一张图片改变大小 * @author FuJianyon
myeclipse集成svn（一针见血） 7454103 eclipse SVN MyEclipse
&n
装箱与拆箱----autoboxing和unboxing darkranger J2SE
4.2　自动装箱和拆箱基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 4.2.1　autoboxing和unboxing 在Java中，所有要处理的东西几乎都是对象(Object)
ajax传统的方式制作ajax aijuans Ajax
//这是前台的代码 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
只用jre的eclipse是怎么编译java源文件的？ avords java eclipse jdk tomcat
eclipse只需要jre就可以运行开发java程序了，也能自动编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ &nb
前端模块化 bee1314 模块化
背景：前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。 JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
处理百万级以上的数据处理 bijian1013 oracle sql 数据库大数据查询
一.处理百万级以上的数据提高查询速度的方法： 1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。 2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
mac 卸载 java 1.7 或更高版本征客丶 java OS
卸载 java 1.7 或更高 sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 成功执行此命令后，还可以执行 java 与 javac 命令 sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 成功执行此命令后，还可以执行 java
【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析 bit1129 Stream
第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中第二部，Spark Streaming读取Kafka中的数据，进行实时分析本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
Erlang vs TNSDL bookjovi erlang
TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个 ljy325 企业应用
　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。相关新闻：（1）IT行业成五大疾病重灾区：过劳死平均37.9岁
读《研磨设计模式》-代码笔记-原型模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /** * Effective Java 建议使用copy constructor or copy factory来代替clone()方法： * 1.public Product copy(Product p){} * 2.publi
配置管理---svn工具之权限配置 chenyu19891124 SVN
今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 pepos component webapps 在conf里面的auth里赋予的权限配置为 [groups]
浅谈程序员的数学修养 comsci 设计模式编程算法面试招聘
浅谈程序员的数学修养
批量执行 bulk collect与forall用法 daizj oracle sql bulk collect forall
BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。有关FORALL语句的用法请参考：批量SQL之 F
Linux下使用rsync最快速删除海量文件的方法 dongwei_6688 OS
1、先安装rsync：yum install rsync 2、建立一个空的文件夹：mkdir /tmp/test 3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。
Yii CModel中rules验证规格 dcj3sjt126com rules yii validate
Yii cValidator主要用法分析： yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError
基于vagrant的redis主从实验 dcj3sjt126com vagrant
平台: Mac 工具: Vagrant 系统: Centos6.5 实验目的: Redis主从实现思路制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box 制作sentos6.5+redis的box mkdir vagrant_redis cd vagrant_
Memcached(二)、Centos安装Memcached服务器 frank1234 centos memcached
一、安装gcc rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]：建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码...... rpm -ivh kernel-head
Remove Duplicates from Sorted List hcx2013 remove
Given a sorted linked list, delete all duplicates such that each element appear only once. For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
Spring4新特性——JSR310日期时间API的支持 jinnianshilongnian spring4
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
浅谈enum与单例设计模式 247687009 java 单例
在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构造器，导出静态成员变量，以便调用者访问。第一种 package singleton; public class Singleton { //导出全局成员 public final static Singleton INSTANCE = new S
使用switch条件语句需要注意的几点 openwrt c break switch
1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 int main() { int n = 1; switch(n) { case 1: printf("--1--\n"); default: printf("defa
配置Spring Mybatis JUnit测试环境的应用上下文 schnell18 spring mybatis JUnit
Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有：单元测试的app context不支持从外部properties文件注入属性 @Value注解不能解析带通配符的路径字符串解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。第二个问题的具体实例是：
Java 定时任务总结一 tuoni java spring timer quartz timertask
Java定时任务总结一.从技术上分类大概分为以下三种方式： 1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务; 说明： java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法 yangshangchuan rank 相似度计算文本相似度词袋模型余弦相似度
本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下： 1、注册多个账号（一般10个以上）。 2、从多个账号中选择一个账号，发表1-2篇博文