Linux 中使用 clone 函数来创建线程

Linux 上创建线程一般使用的是 pthread 库  实际上 libc 也给我们提供了创建线程的函数  那就是 clone

int clone(int (*fn)(void *),
           void *child_stack,
           int flags, void *arg, ...
           /* pid_t *ptid, struct user_desc *tls, pid_t *ctid */ );

man 手册里面说的很清楚这个函数存在的意义就是实现 线程  当然这个函数不是 linux 的系统调用，而是对系统调用的封装 。    

    首先需要给新的线程创建个堆栈 ，使用函数 mmap ,这函数常用来完成文件映射  这里分配内存也是可以的

void *pstack = (void *)mmap(NULL,
                            STACK_SIZE,
                            PROT_READ | PROT_WRITE ,
                            MAP_PRIVATE | MAP_ANONYMOUS | MAP_ANON ,//| MAP_GROWSDOWN ,
                            -1,
                            0);

通过指定  MAP_ANONYMOUS 标识  系统就不会创建文件映射 而仅仅分配内存

注意堆栈不要太小了  不然会溢出的 。。

然后调用 clone 函数

ret = clone(thread_func,
            (void *)((unsigned char *)pstack + STACK_SIZE),
            CLONE_VM | CLONE_FS | CLONE_THREAD | CLONE_FILES | CLONE_SIGHAND | SIGCHLD,
            (void *)NULL);

注意堆栈是向下增长的  所以指定对战的内存的时候 要使用分配内存的尾部的指针

几个标识的意义
CLONE_VM  (0x100)tells the kernel to let the original process and the clone in the same memory space;
CLONE_FS (0x200)both get the same file system information;
CLONE_FILES (0x400)share file descriptors;
CLONE_SIGHAND (0x800)both processes share the same signal handlers;
CLONE_THREAD (0x10000) this tells the kernel, that both processes would belong to the same thread group (be threads within the same process); 

在线程函数中 直接  return 就可以退出线程了。。。。

  使用 clone 的时候 指定 CLONE_THREAD 那么以后就不能使用 wait 来等待这个线程了 相当于 deteched .了。。。
查看man 手册可以看到

A new thread created with CLONE_THREAD has the same parent process as the caller of clone() (i.e., like CLONE_PARENT), so that calls  to getppid(2)  return the same value for all of the threads in a thread group.  When a CLONE_THREAD thread terminates, the thread that created it using clone() is not sent a SIGCHLD (or other termination) signal; nor can the  status  of  such  a  thread  be  obtained  using wait(2).  (The thread is said to be detached.)

下面是我测试的代码

#define _GNU_SOURCE /* or _BSD_SOURCE or _SVID_SOURCE */
#include <unistd.h>
#include <sys/syscall.h> /* For SYS_xxx definitions */
#include <sys/types.h>
#include <sched.h>
#include <sys/mman.h>
#include <signal.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>

#define STACK_SIZE 1024*1024*8 //8M

int thread_func(void *lparam)
{
    printf("thread id %d \n", (int)syscall(SYS_gettid));
    printf("thread get param : %d \n", (int)lparam);
    sleep(1);
    return 0;
}


void child_handler(int sig)
{
    printf("I got a SIGCHLD\n");
}

int main(int argc, char **argv)
{
    setvbuf(stdout, NULL, _IONBF, 0);
    signal(SIGCHLD, child_handler);
    //signal(SIGUSR1, SIG_IGN);

    void *pstack = (void *)mmap(NULL,
                                STACK_SIZE,
                                PROT_READ | PROT_WRITE ,
                                MAP_PRIVATE | MAP_ANONYMOUS | MAP_ANON ,//| MAP_GROWSDOWN ,
                                -1,
                                0);
    if (MAP_FAILED != pstack)
    {
        int ret;
        printf("strace addr : 0x%X\n", (int)pstack);
        /*
        CLONE_VM (0x100) - tells the kernel to let the original process and the clone in the same memory space;
        CLONE_FS (0x200) - both get the same file system information;
        CLONE_FILES (0x400) - share file descriptors;
        CLONE_SIGHAND (0x800) - both processes share the same signal handlers;
        CLONE_THREAD (0x10000) - this tells the kernel, that both processes would belong to the same thread group (be threads within the same process);
        */
        ret = clone(thread_func,
                    (void *)((unsigned char *)pstack + STACK_SIZE),
                    CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |SIGCHLD,
                    (void *)NULL);
        if (-1 != ret)
        {
            pid_t pid = 0;
            printf("start thread %d \n", ret);
            sleep(5);
            pid = waitpid(-1, NULL, __WCLONE | __WALL);
            printf("child : %d exit %s\n", pid,strerror(errno));
        }
        else
        {
            printf("clone failed %s\n", strerror(errno) );
        }
    }
    else
    {
        printf("mmap() failed %s\n", strerror(errno));
    }
    return 0;
}