python中的进程_python 中的进程 ，线程 和 亲缘性 - 柳争的博客 var liuzheng = {name:"柳争",spoken:"学而践，习而思 ,...

Affinity

在系统引导的时候，系统决定该计算机中有几个CPU可以被使用。在应用程序中，可以呼叫GetSystemInfo函数来取得CPU的数量。

一般地，线程可以运行在任何一个CPU上，当然，你可以使用Windows自带的“soft affinity”机制，让Windows自动分配CPU给一个线程。

或许，你更希望能够对分配给线程的CPU有一些限制，使用“hard affinity”机制。

SetProcessAffinityMask函数限制一个特定的进程只能运行在CPU的一个子集上。

BOOL SetProcessAffinityMask(HANDLE hProcess, DWORD_PTR dwProcessAffinityMask);

该函数得第一个参数指明了要被限制的进程，第二个参数是一个“位屏蔽”数据，里面的每个位表示一个CPU代号(从0开始标号)，比如0x00000001表示选中CPU 0，也就是“该进程中的线程”只能运行在CPU 0上了；0x00000005表示同时选中CPU 0和CPU 2。

一个进程中的子进程可以继承该进程的相关性，也可以使用作业内核对象对某些进程限制在要求的一组CPU上执行。

BOOL GetProcessAffinityMask(

HANDLE hProcess,

PDWORD_PTR pdwProcessAffinityMask,

PDWORD_PTR pdwSystemAffinityMask);

该函数通过第二个参数返回指定进程的CPU的相关性信息，同时可以通过第三个参数返回系统相关性信息。系统相关性指明系统的哪些CPU可以处理线程，进程的相关性始终是系统相关性的子集。

以上讨论的是如何把一个进程中的所有线程限制在一组CPU上。有的时候想要把进程的一个具体线程限制在一组CPU上。

SetThreadAffinityMask函数可以限制某一个线程只能运行在一组CPU上。

DWORD_PTR SetThreadAffinityMask(

HANDLE hThread,

DWORD_PTR dwThreadAffinityMask);

该函数的第二个参数的意义和SetProcessAffinityMask函数中的第二个参数相同。也必须指明了一个正确的CPU子集，限制指定的线程只能运行在这个CPU子集上。该函数返回原来的线程的相关信息。

比如，现在有4个线程和4个可用的CPU，你想让线程1独占CPU 0，让其他3个线程只能运行在CPU 1、CPU 2、CPU 3上，可以如下编码：

SetThreadAffinityMask(hThread0, 0x00000001); 0001

SetThreadAffinityMask(hThread1, 0x0000000E); 1110

SetThreadAffinityMask(hThread2, 0x0000000E); 1110

SetThreadAffinityMask(hThread3, 0x0000000E); 1110

python 中的Affinity:

http://pypi.python.org/pypi/affinity

查看你的服务器有几个核：

cat /proc/cpuinfo |grep -c processor

python  fastcgi中的多进程和多线程

多进程：

while len(self._children) < self._maxSpare:

if not self._spawnChild(sock): break

def _spawnChild(self, sock):

"""

Spawn a single child. Returns True if successful, False otherwise.

"""

# This socket pair is used for very simple communication between

# the parent and its children.

parent, child = socket.socketpair()

parent.setblocking(0)

setCloseOnExec(parent)

child.setblocking(0)

setCloseOnExec(child)

try:

pid = os.fork()

except OSError, e:

if e[0] in (errno.EAGAIN, errno.ENOMEM):

return False # Can't fork anymore.

raise

if not pid:

# Child

child.close()

# Put child into its own process group.

pid = os.getpid()

os.setpgid(pid, pid)

# Restore signal handlers.

self._restoreSignalHandlers()

# Close copies of child sockets.

for f in [x['file'] for x in self._children.values()

if x['file'] is not None]:

f.close()

self._children = {}

try:

# Enter main loop.

self._child(sock, parent)

except KeyboardInterrupt:

pass

sys.exit(0)

else:

# Parent

parent.close()

d = self._children[pid] = {}

d['file'] = child

d['avail'] = True

return True

多线程：

while self._idleCount < self._minSpare and \

self._workerCount < self._maxThreads:

self._workerCount += 1

self._idleCount += 1

thread.start_new_thread(self._worker, ())

def _worker(self):

"""

Worker thread routine. Waits for a job, executes it, repeat.

"""

self._lock.acquire()

while True:

while not self._workQueue:

self._lock.wait()

# We have a job to do...

job = self._workQueue.pop(0)

assert self._idleCount > 0

self._idleCount -= 1

self._lock.release()

try:

job.run()

except:

# FIXME: This should really be reported somewhere.

# But we can't simply report it to stderr because of fcgi

pass

self._lock.acquire()

if self._idleCount == self._maxSpare:

break # NB: lock still held

self._idleCount += 1

assert self._idleCount <= self._maxSpare

# Die off...

assert self._workerCount > self._maxSpare

self._workerCount -= 1

self._lock.release()

自己动手编写fork

def mprocess(info):

pid = os.fork()

if pid == 0:

pid = os.getpid()

print "child pid",pid

while True:

time.sleep(1)

print info

sys.exit(0)

else:

pid = os.getpid()

print "parent id",pid

if __name__ == "__main__":

for i in range(2):

mprocess("haha_%s" % i)

child pid 26994

child pid 26993

parent id 26992

parent id 26991

child pid 26995

child pid 26996

parent id 26991

parent id 26992

haha_0

haha_0

haha_1

haha_1

haha_0

haha_0

haha_1

haha_1

haha_0

分享到：

2011-03-04 14:00

浏览 957

论坛回复 / 浏览 (0 / 4238)

评论