python 中的进程 ，线程 和 亲缘性

进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：
简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程，使得多线程程序的并发性高。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。

线程是独立运行的，它且并不知道进程中还有其他线程存在。线程的执行是抢占式的，也就是说，当前运行的线程在任何时候都可能被挂起，以便另外一个线程可以运行。

每一个线程都设置了优先限权；在任何时候，只要线程已经准备就绪，具有高优先权的线程总是首先运行。如果线程具有相同的悠闲权，则根据时间片进行轮转调度。上下文的切换包括了保存和恢复线程状态。这个状态不仅仅包含了处理器寄存器（进程上下文）而且还包含了线程可访问的地址空间（进程上下文）。只有在重新调度是在两个进程间进行的时候，进程上下文才被切换。

线程创建以后，它具有EPriorityNormal的默认优选级。线程被初始化并处于挂起状态，这意味着在线程开始运行前，线程的运行优先级可以被改变。

[size=large][color=red]Affinity[/color][/size]

在系统引导的时候，系统决定该计算机中有几个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上。
D

WORD_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:
[url]http://pypi.python.org/pypi/affinity[/url]

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

cat /proc/cpuinfo |grep -c processor

[size=large][color=red] python fastcgi中的多进程和多线程[/color]
[/size]

多进程：

 
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()

:arrow:

自己动手编写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