Linux  (转自cu)
原文链接:  http://linux.chinaunix.net/bbs/viewthread.php?tid=904906
cpu.c 

[CODE] 
#include<stdlib.h> 
#include<stdio.h> 
#include<sys/types.h> 
#include<sys/sysinfo.h> 
#include<unistd.h> 

#define __USE_GNU 
#include<sched.h> 
#include<ctype.h> 
#include<string.h> 

int main(int argc, char* argv[]) 

        int num = sysconf(_SC_NPROCESSORS_CONF); 
        int created_thread = 0; 
        int myid; 
        int i; 
        int j = 0; 

        cpu_set_t mask; 
        cpu_set_t get; 

        if (argc != 2) 
        { 
                printf("usage : ./cpu num/n"); 
                exit(1); 
        } 

        myid = atoi(argv[1]); 

        printf("system has %i processor(s). /n", num); 

        CPU_ZERO(&mask); 
        CPU_SET(myid, &mask); 

        if (sched_setaffinity(0, sizeof(mask), &mask) == -1) 
        { 
                printf("warning: could not set CPU affinity, continuing.../n"); 
        } 
        while (1) 
        { 

                CPU_ZERO(&get); 
                if (sched_getaffinity(0, sizeof(get), &get) == -1) 
                { 
                        printf("warning: cound not get cpu affinity, continuing.../n"); 
                } 
                for (i = 0; i < num; i++) 
                { 
                        if (CPU_ISSET(i, &get)) 
                        { 
                                printf("this process %d is running processor : %d/n",getpid(), i); 
                        } 
                } 
        } 
        return 0; 

[/CODE] 

下面是在两个终端分别执行了./cpu 0  ./cpu 2 后得到的结果. 效果比较明显.  


Cpu0  :  5.3%us,  5.3%sy,  0.0%ni, 87.4%id,  0.0%wa,  0.0%hi,  2.0%si,  0.0%st 
Cpu1  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st 
Cpu2  :  5.0%us, 12.2%sy,  0.0%ni, 82.8%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st 
Cpu3  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st 
Cpu4  :  0.0%us,  0.0%sy,  0.0%ni, 99.7%id,  0.3%wa,  0.0%hi,  0.0%si,  0.0%st 
Cpu5  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st 
Cpu6  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st 
Cpu7  :  0.0%us,  0.0%sy,  0.0%ni,100.0%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st 

#ifdef __USE_GNU 
/* Access macros for `cpu_set'.  */ 
#define CPU_SETSIZE __CPU_SETSIZE 
#define CPU_SET(cpu, cpusetp)   __CPU_SET (cpu, cpusetp) 
#define CPU_CLR(cpu, cpusetp)   __CPU_CLR (cpu, cpusetp) 
#define CPU_ISSET(cpu, cpusetp) __CPU_ISSET (cpu, cpusetp) 
#define CPU_ZERO(cpusetp)       __CPU_ZERO (cpusetp) 


/* Set the CPU affinity for a task */ 
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, 
                              __const cpu_set_t *__cpuset) __THROW; 

/* Get the CPU affinity for a task */ 
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, 
                              cpu_set_t *__cpuset) __THROW; 
#endif 
#define __USE_GNU是为了使用CPU_SET()等宏. 具体在/usr/include/sched.h中有如下的定义.  



CPU Affinity (CPU亲合力) 

CPU亲合力就是指在Linux系统中能够将一个或多个进程绑定到一个或多个处理器上运行. 
一个进程的CPU亲合力掩码决定了该进程将在哪个或哪几个CPU上运行.在一个多处理器系统中,设置CPU亲合力的掩码可能会获得更好的性能. 
一个CPU的亲合力掩码用一个cpu_set_t结构体来表示一个CPU集合,下面的几个宏分别对这个掩码集进行操作: 
CPU_ZERO() 清空一个集合 
CPU_SET()与CPU_CLR()分别对将一个给定的CPU号加到一个集合或者从一个集合中去掉. 
CPU_ISSET()检查一个CPU号是否在这个集合中. 
其实这几个的用法与select()函数那几个调用差不多. 
下面两个函数就是最主要的了: 
sched_setaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask) 
该函数设置进程为pid的这个进程,让它运行在mask所设定的CPU上.如果pid的值为0,则表示指定的是当前进程,使当前进程运行在mask所设定的那些CPU上.第二个参数cpusetsize是 

mask所指定的数的长度.通常设定为sizeof(cpu_set_t).如果当前pid所指定的CPU此时没有运行在mask所指定的任意一个CPU上,则该指定的进程会从其它CPU上迁移到mask的指定的 

一个CPU上运行. 
sched_getaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask) 
该函数获得pid所指示的进程的CPU位掩码,并将该掩码返回到mask所指向的结构中.即获得指定pid当前可以运行在哪些CPU上.同样,如果pid的值为0.也表示的是当前进程. 

这几个宏与函数的具体用法前面已经有讲解. 

关于cpu_set_t的定义 
[CODE] 
# define __CPU_SETSIZE  1024 
# define __NCPUBITS     (8 * sizeof (__cpu_mask)) 

typedef unsigned long int __cpu_mask; 

# define __CPUELT(cpu)  ((cpu) / __NCPUBITS) 
# define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS)) 

typedef struct 

  __cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS]; 
} cpu_set_t; 

# define __CPU_ZERO(cpusetp) / 
  do {                                                                        / 
    unsigned int __i;                                                         / 
    cpu_set_t *__arr = (cpusetp);                                             / 
    for (__i = 0; __i < sizeof (cpu_set_t) / sizeof (__cpu_mask); ++__i)      / 
      __arr->__bits[__i] = 0;                                                 / 
  } while (0) 
# define __CPU_SET(cpu, cpusetp) / 
  ((cpusetp)->__bits[__CPUELT (cpu)] |= __CPUMASK (cpu)) 
# define __CPU_CLR(cpu, cpusetp) / 
  ((cpusetp)->__bits[__CPUELT (cpu)] &= ~__CPUMASK (cpu)) 
# define __CPU_ISSET(cpu, cpusetp) / 
  (((cpusetp)->__bits[__CPUELT (cpu)] & __CPUMASK (cpu)) != 0) 

[/CODE] 

在我的机器上sizeof(cpu_set_t)的大小为128,即一共有1024位.第一位代表一个CPU号.某一位为1则表示某进程可以运行在该位所代表的cpu上.例如 
CPU_SET(1, &mask); 
则mask所对应的第2位被设置为1. 
此时如果printf("%d/n", mask.__bits[0]);就打印出2.表示第2位被置为1了. 



具体我是参考man sched_setaffinity文档中的函数的.  
然后再参考了一下IBM的 developerWorks上的一个讲解.  
http://www.ibm.com/developerworks/cn/linux/l-affinity.html

-----------------------------------------------------------------


windows

  首先用API函数创建一个线程,
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES
lpThreadAttributes,  // SD
SIZE_T dwStackSize, // initial stack size
LPTHREAD_START_ROUTINE lpStartAddress, // thread function
LPVOID lpParameter, // thread argument
DWORD dwCreationFlags, // creation option
LPDWORD lpThreadId     // thread identifier
);
 
通过调用SetThreadAffinityMask,就能为各个线程设置亲缘性屏蔽:   
DWORD_PTR SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffinityMask );
该函数中的hThread参数用于指明要限制哪个线程,
dwThreadAffinityMask用于指明该线程能够在哪个CPU上运行。
dwThreadAffinityMask必须是进程的亲缘性屏蔽的相应子集。
返回值是线程的前一个亲缘性屏蔽。因此,若要将3个线程限制到CPU1、2和3上去运行,可以这样操作:
//Thread 0 can only run on CPU 0.
SetThreadAffinityMask(hThread0, 0x00000001);

//Threads 1, 2, 3 run on CPUs 1.
SetThreadAffinityMask(hThread1, 0x0000000E);