1. shared memoryを使う
2. server processを使う

１は一般的な共有メモリを使うという方法．型は，arrayモジュールの書式に従う(ctypeと言うべきか)． 大きく分けて２つあり，ArrayとValueである． スノーピーク×ユニフレーム ツインバーナー US-2400 UNIFLAME"> (ctypeについてはいつか…いつの日にか…．cのsharedが使えるようにする，早い話) オークリー サングラス Twenty XX">

#!/usr/bin/env python
#coding:utf-8
from multiprocessing import Process, Manager
def func(l, d):
    l.append(1)
    d.update({2:"hello"})
    d[10] = "world"
if __name__ == "__main__":
    manager = Manager()
    l = manager.list(range(2))
    d = manager.dict()
    p = Process(target=func, args=(l,d))
    p.start()
    p.join()
    print(l)
    print(d)

$ python multiproc01.py
[0, 1, 1]
{2:"hello", 10:"world"}

と通信が出来る．これ以上は骨が折れるので，簡単なサンプルを示す． CPU使用量(/proc/stat)，物理メモリ(/proc/meminfo)，ネットワーク(/proc/net/dev)，ロードアベレージ(/proc/loadavg)を並列して取得する．
(実際はロードアベレージ以外を取得する)
並行でやることもないようなものだが，サンプルとしては丁度よいか．

次にQueue，Pipeを使っての処理．Queueはいわゆる生産者/消費者モデルの簡単な例である． Pipeも似たものであるが，双方向の通信が可能．Queueは一方通行という感じか． Nintendo Switch NINTENDO SWITCH LITE グレー">

from multiprocessing import Pipe, Process
import time
import datetime
import random
import math
def genRandom(conn):
    while True:
        if conn.poll():
            if conn.recv() is None:
                conn.close()
                break
        else:
            time.sleep(random.randint(1,15)*0.01)
            conn.send(random.normalvariate(10, 0.6))
    print("connection closed")
    conn.close()
def cleanUp(arr):
    return filter(lambda x: x is not None, arr)
def getMean(arr):
    return 1.*sum(arr)/len(arr)
def getStd(arr):
    m = getMean(arr)
    return math.sqrt(sum(map(lambda x: (x - m)*(x - m), arr))/len(arr))
if __name__ == '__main__':
    ## create Pipe instance and Process instance
    ## Pipe returns two instance; parent and child
    ##     child will run in subprocess
    ##     parent will manage child
    parent_conn, child_conn = Pipe()
    p = Process(target=genRandom, args=(child_conn, ))
    p.daemon = True
    ## check current date
    start_time = datetime.datetime.now()
    p.start()  # process start
    timeinterval = 10     # sec
    timeinterval = datetime.timedelta(seconds=timeinterval)
    sample_size = 1e2
    i = 0
    data_array = [None] * int(sample_size)
    while i < int(sample_size):
        print(p.is_alive())
        current_time = datetime.datetime.now()
        if (current_time - start_time) > timeinterval:   # elapsed setting value, break loop
            print("time out!")
            break
        else:
            res = parent_conn.recv()
            data_array[i] = res
            if i % 10 == 0 and i != 0:
                print("{0:%x %X}: {1:.2f}".format(datetime.datetime.now(), res))
        i += 1
    ## at first send "Signal" to child
    parent_conn.send(None)
    p.join()   # join Process
    data_array = cleanUp(data_array)
    print("total event: {0}".format(i))
    print("mean: {0}, std: {1}".format(getMean(data_array), getStd(data_array)))
    print("done")

子プロセスはランダム秒待って乱数を親プロセスに送る． 親プロセスはひたすらそれを集める． 子プロセスを親は直接殺さない． 終了のシグナルとしてNoneを子プロセスに送り，子プロセスは読み取るべきデータがあり(pollメソッドで判断) かつそれがNoneで有るときにプロセスを終了する． (multiprocessingのValueではなく，managerクラスのValueやArrayを使うべきである．後者はProxyオブジェクトなので 安全に共有メモリにアクセスでき，必要であればロックを掛けることが出来る．) そこでこれを回避するために，もうひとつ処理専門のプロセスを作りデータを投げてやるのだ．
それがこれ． Plage reversible boa ブルゾン"> (要pyROOT)
メインのスクリプトでは，単にプロセスの管理だけを行なっている． 一定時間経過したあるいは一定のイベント数に到達したかを判断し，それに応じてプロセスに司令を与える．