使用 ProcessBuilder 执行python程序没有运行 python process start

python 多进程编程

python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，Python会完成其他所有事情。借助这个包，可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。

1、Process

Process构造函数主要有两个参数，target表示要运行的函数名，args表示传递的参数。

方法：

is_alive()、join([timeout])、run()、start()、terminate()。

run和start的区别：

start()方法
开始线程活动。
对每一个线程对象来说它只能被调用一次，它安排对象在一个另外的单独线程中调用run()方法（而非当前所处线程）。
当该方法在同一个线程对象中被调用超过一次时，会引入RuntimeError(运行时错误)。
run()方法
代表了线程活动的方法。
你可以在子类中重写此方法。标准run()方法调用了传递给对象的构造函数的可调对象作为目标参数，如果有这样的参数的话，顺序和关键字参数分别从args和kargs取得。

所以简单地说，start就是另外开启一个进程来运行这个函数，run就是在当前进程下开始这个函数。

import multiprocessing


def worker(value1, value2):
    print(multiprocessing.current_process())

p1 = multiprocessing.Process(target=worker, args=(1, 2,))
p2 = multiprocessing.Process(target=worker, args=(3, 4,))
p1.run()
p2.start()

<_MainProcess(MainProcess, started)>
<Process(Process-2, started)>

daemon 后台驻留程序

意思就是说，如果主进程运行结束，则结束子进程。

import multiprocessing
import time


def worker(value1, value2):
    time.sleep(1)
    print(multiprocessing.current_process())

p1 = multiprocessing.Process(target=worker, args=(1, 2,))
p2 = multiprocessing.Process(target=worker, args=(3, 4,))
p1.daemon = True
p2.daemon = True
p1.start()
p2.start()
print("end")

end

import multiprocessing
import time


def worker(value1, value2):
    time.sleep(1)
    print(multiprocessing.current_process())

p1 = multiprocessing.Process(target=worker, args=(1, 2,))
p2 = multiprocessing.Process(target=worker, args=(3, 4,))
p1.daemon = True
p2.daemon = True
p1.start()
p2.start()
p1.join()
p2.join()
print("end")

<Process(Process-1, started daemon)>
<Process(Process-2, started daemon)>
end

需要注意的是，如果调用的是run，则会正常输出，因为run是在当前进程中运行。

Lock

通过锁来解决进程间数据同步问题。
可以通过两种方式来使用Lock。

import multiprocessing
import time


def worker(lock, value2):
    with lock:
        print(lock)
        print(value2)
    lock.acquire()
    print(lock)
    print(value2)
    lock.release()

lock = multiprocessing.Lock()
p1 = multiprocessing.Process(target=worker, args=(lock, 2,))
p2 = multiprocessing.Process(target=worker, args=(lock, 4,))
p1.run()
p2.run()

Semaphore

信号量，和PV原语使用方法是一致的，可以用来控制对共享资源的最大连接数。

import multiprocessing
import time


def worker(s, i):
    s.acquire()
    print(multiprocessing.current_process().name + "acquire")
    time.sleep(i)
    print(multiprocessing.current_process().name + "release\n")
    s.release()

if __name__ == "__main__":
    s = multiprocessing.Semaphore(2)
    for i in range(5):
        p = multiprocessing.Process(target = worker, args=(s, i*2))
        p.start()

Process-1acquire
Process-1release

Process-2acquire
Process-3acquire
Process-2release

Process-4acquire
Process-3release

Process-5acquire
Process-4release

Process-5release

Queue 实现读者写者问题

Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。

get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常。Queue的一段示例代码：

import multiprocessing
import time

def writer_proc(q):
    while True:
        try:
            q.put(1, block = False)
        except:
            pass


def reader_proc(q):
    while True:
        try:
            print q.get(block = False)
        except:
            time.sleep(1)
            pass

if __name__ == "__main__":
    q = multiprocessing.Queue(3)
    writer = multiprocessing.Process(target=writer_proc, args=(q,))
    writer.start()

    reader = multiprocessing.Process(target=reader_proc, args=(q,))
    reader.start()

    reader.join()
    writer.join()

pipe 用于实现IPC（进程间通信）

Pipe方法返回(conn1, conn2)代表一个管道的两个端。Pipe方法有duplex参数，如果duplex参数为True(默认值)，那么这个管道是全双工模式，也就是说conn1和conn2均可收发。duplex为False，conn1只负责接受消息，conn2只负责发送消息。

send和recv方法分别是发送和接受消息的方法。例如，在全双工模式下，可以调用conn1.send发送消息，conn1.recv接收消息。如果没有消息可接收，recv方法会一直阻塞。如果管道已经被关闭，那么recv方法会抛出EOFError。

import multiprocessing
import time

def proc1(pipe):
    while True:
        for i in xrange(10000):
            print "send: %s" %(i)
            pipe.send(i)
            time.sleep(1)

def proc2(pipe):
    while True:
        print "proc2 rev:", pipe.recv()
        time.sleep(1)

def proc3(pipe):
    while True:
        print "PROC3 rev:", pipe.recv()
        time.sleep(1)

if __name__ == "__main__":
    pipe = multiprocessing.Pipe()
    p1 = multiprocessing.Process(target=proc1, args=(pipe[0],))
    p2 = multiprocessing.Process(target=proc2, args=(pipe[1],))
    #p3 = multiprocessing.Process(target=proc3, args=(pipe[1],))

    p1.start()
    p2.start()
    #p3.start()

    p1.join()
    p2.join()
    #p3.join()

Pool 进程池

在利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，十几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，此时可以发挥进程池的功效。
Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。

函数解释：

• apply_async(func[, args[, kwds[, callback]]]) 它是非阻塞，apply(func[, args[, kwds]])是阻塞的（理解区别，看例1例2结果区别）
• close() 关闭pool，使其不在接受新的任务。
• terminate() 结束工作进程，不在处理未完成的任务。
• join() 主进程阻塞，等待子进程的退出， join方法要在close或terminate之后使用。

非阻塞

#coding: utf-8
import multiprocessing
import time

def func(msg):
    print "msg:", msg
    time.sleep(3)
    print "end"

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 3)
    for i in xrange(4):
        msg = "hello %d" %(i)
        pool.apply_async(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去

    print "Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~"
    pool.close()
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    print "Sub-process(es) done."

mMsg: hark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~ello 0

msg: hello 1
msg: hello 2
end
msg: hello 3
end
end
end
Sub-process(es) done.

就算是说，主进程不需要等待子进程运行完，主进程可以独立完成自己的任务。

阻塞

#coding: utf-8
import multiprocessing
import time

def func(msg):
    print "msg:", msg
    time.sleep(3)
    print "end"

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 3)
    for i in xrange(4):
        msg = "hello %d" %(i)
        pool.apply(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去

    print "Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~"
    pool.close()
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    print "Sub-process(es) done."

msg: hello 0
end
msg: hello 1
end
msg: hello 2
end
msg: hello 3
end
Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~
Sub-process(es) done.

主进程必须等待子进程运行完才能够继续执行自己的代码。

进程池中的进程间数据共享

import multiprocessing
import time


def worker(array, value):
    with lock:
        array.append(value)


def init(l):
    global lock
    lock = l

manager = multiprocessing.Manager()
globalArray = manager.list()
l = multiprocessing.Lock()
print(time.clock())
pool = multiprocessing.Pool(5, initializer=init, initargs=(l,))
for i in range(10):
    pool.apply_async(worker, args=(globalArray, i,))
pool.close()
pool.join()
print(len(globalArray))

值得注意的是，manager中是需要加锁的，具体原因如下：

import multiprocessing
import time


def worker(array, value):
    with lock:
        time.sleep(1 - value / 10)
        array.append(value)


def init(l):
    global lock
    lock = l

manager = multiprocessing.Manager()
globalArray = manager.list()
l = multiprocessing.Lock()
pool = multiprocessing.Pool(5, initializer=init, initargs=(l,))
for i in range(10):
    pool.apply_async(worker, args=(globalArray, i,))
pool.close()
pool.join()
print(globalArray)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

import multiprocessing
import time


def worker(array, value):
    time.sleep(1 - value / 10)
    array.append(value)


def init(l):
    global lock
    lock = l

manager = multiprocessing.Manager()
globalArray = manager.list()
l = multiprocessing.Lock()
pool = multiprocessing.Pool(5, initializer=init, initargs=(l,))
for i in range(10):
    pool.apply_async(worker, args=(globalArray, i,))
pool.close()
pool.join()
print(globalArray)

[1, 0, 2, 3, 4, 5, 6, 7, 8, 9]

可以发现两种做法的结果是不一样的，所以是需要进行加锁的。

文中部分内容引用python多进程编程