Liunx下clone函数分析第二篇

最新推荐文章于 2021-05-17 21:43:47 发布
最新推荐文章于 2021-05-17 21:43:47 发布
阅读量234 收藏 1
点赞数
分类专栏： # 并发控制 文章标签： c语言 操作系统 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anonfish/article/details/115015243
版权

Liunx下clone函数分析(二)

动机

这一篇继续探究clone函数,部分不同参数的运行情况。

clone

参数：

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

fn是指向子进程执行时调用的函数，fnarg是可以传给该函数的参数，child_stack是为子进程分配的堆栈指针，arg是传给子进程的参数一般为0.

下面是flags可以取的值
CLONE_PARENT 创建的子进程的父进程是调用者的父进程，新进程与创建它的进程成了“兄弟”而不是“父子”
CLONE_FS 子进程与父进程共享相同的文件系统，包括root、当前目录、umask
CLONE_FILES 子进程与父进程共享相同的文件描述符（file descriptor）表
CLONE_NEWNS 在新的namespace启动子进程，namespace描述了进程的文件hierarchy
CLONE_SIGHAND 子进程与父进程共享相同的信号处理（signal handler）表
CLONE_PTRACE 若父进程被trace，子进程也被trace
CLONE_VFORK 父进程被挂起，直至子进程释放虚拟内存资源
CLONE_VM 子进程与父进程运行于相同的内存空间
CLONE_PID 子进程在创建时PID与父进程一致
CLONE_THREAD Linux 2.4中增加以支持POSIX线程标准，子进程与父进程共享相同的线程群

原文链接：https://blog.csdn.net/gogokongyin/article/details/51178257

clone31-1Test.c

#define  _GNU_SOURCE 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#include <sched.h>
#include <signal.h>

#include <sys/types.h>
#include <unistd.h>


#define FIBER_STACK 8192
#define CLONE_NUM 5

int a;
void * stacks[CLONE_NUM];


 	int myParams0 = 0 ;
 	int myParams1 = 1 ;
 	int myParams2 = 2 ;
 	int myParams3 = 3 ;
 	int myParams4 = 4 ;
		
int do_something(void *lparam)
{
    int i;
    int j;
    i = (int)lparam;
   
    //int a=0;
    
    for (j=0;j<10000;j++)
       ++a;
    
    printf("This is son, the pid is:%d, the param is: %d, the a is: %d\n", getpid(), i , a);

    //free(stacks[i]); //这里我也不清楚，如果这里不释放，不知道子线程死亡后，该内存是否会释放，知情者可以告诉下,谢谢
    exit(1);
}

int do_loop_time()
{
  int i,j,k;
  for (i=0;i<1000;i++)
    for (j=0;j<1000;j++)
      for (k=0;k<1000;k++)
	;
}

int cloneMethod1()
{
		clone(&do_something, (char *)(stacks[myParams0]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams0);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams1]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams1);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams2]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams2);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams3]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams3);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams4]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams4);//创建子线程   

}

int cloneMethod2()
{
    int i;
    for (i=0;i<CLONE_NUM;i++)
    {
		clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}

int cloneMethod3()
{
    int i;
    
    pid_t parentPID = getpid();
    pid_t myPID;
    for (i=0;i<CLONE_NUM;i++)
    {
		myPID = getpid();
		if (myPID == parentPID)
			clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}



int main()
{
    int i;
    a =0;
    
    for (i=0;i<CLONE_NUM;i++)
    {
	stacks[i] = malloc(FIBER_STACK);//为子进程申请系统堆栈   
        if(!stacks[i])
        {
			printf("The stack failed\n");
			exit(0);
	    }
    }


    printf("creating son thread!!!\n");
    cloneMethod1();

    
    char ch;
    scanf("%c",&ch);
    
    printf("This is father, my pid is: %d, the a is: %d\n", getpid(), a);
    
     for (i=0;i<CLONE_NUM;i++)
    {
//		free(stacks[i]) ;   
    }   
   
    exit(1);
}

输出

 [tj@tj bin]$ ./clone31-1Test 
creating son thread!!!
This is son, the pid is:15539, the param is: 0, the a is: 10000
This is son, the pid is:15540, the param is: 1, the a is: 16321
1
This is father, my pid is: 15538, the a is: 16321

[tj@tj bin]$ ./clone31-1Test 
creating son thread!!!
This is son, the pid is:15568, the param is: 0, the a is: 10302
This is son, the pid is:15569, the param is: 1, the a is: 13520
1
This is father, my pid is: 15567, the a is: 13520

[tj@tj bin]$ ./clone31-1Test 
creating son thread!!!
This is son, the pid is:15572, the param is: 1, the a is: 13604
This is son, the pid is:15571, the param is: 0, the a is: 11317
1
This is father, my pid is: 15570, the a is: 13604

结果分析
此示例运行了三次，由二和第三个可以看出clone的2个子线程是并行的。第一个是偶发原因，至少是第一个子线程运行完了for循环，第二个子线程才进入for循环。

clone31-2Test.c

#define  _GNU_SOURCE 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#include <sched.h>
#include <signal.h>

#include <sys/types.h>
#include <unistd.h>


#define FIBER_STACK 8192
#define CLONE_NUM 5

int a;
void * stacks[CLONE_NUM];


 		int myParams0 = 0 ;
 		int myParams1 = 1 ;
 		int myParams2 = 2 ;
 		int myParams3 = 3 ;
 		int myParams4 = 4 ;
		
int do_something(void *lparam)
{
    int i;
    int j;
    i = (int)lparam;
   
    //int a=0;
    
    for (j=0;j<10000;j++)
      printf("This is son, the pid is:%d, the param is: %d, the a is: %d\n", getpid(), i , ++a);
    
    printf("This is son, the pid is:%d, the param is: %d, the a is: %d\n", getpid(), i , a);

    //free(stacks[i]); //这里我也不清楚，如果这里不释放，不知道子线程死亡后，该内存是否会释放，知情者可以告诉下,谢谢
    exit(1);
}

int do_loop_time()
{
  int i,j,k;
  for (i=0;i<1000;i++)
    for (j=0;j<1000;j++)
      for (k=0;k<1000;k++)
	;
}

int cloneMethod1()
{
		clone(&do_something, (char *)(stacks[myParams0]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams0);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams1]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams1);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams2]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams2);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams3]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams3);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams4]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams4);//创建子线程   

}

int cloneMethod2()
{
    int i;
    for (i=0;i<CLONE_NUM;i++)
    {
		clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}

int cloneMethod3()
{
    int i;
    
    pid_t parentPID = getpid();
    pid_t myPID;
    for (i=0;i<CLONE_NUM;i++)
    {
		myPID = getpid();
		if (myPID == parentPID)
			clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}



int main()
{
    int i;
    a =0;
    
    for (i=0;i<CLONE_NUM;i++)
    {
	stacks[i] = malloc(FIBER_STACK);//为子进程申请系统堆栈   
        if(!stacks[i])
        {
			printf("The stack failed\n");
			exit(0);
	    }
    }



    printf("creating son thread!!!\n");
    cloneMethod1();
    
    
    char ch;
    scanf("%c",&ch);
    
    printf("This is father, my pid is: %d, the a is: %d\n", getpid(), a);
    
     for (i=0;i<CLONE_NUM;i++)
    {
//		free(stacks[i]) ;   
    }   
    

    exit(1);
}

输出

...
...
This is son, the pid is:15747, the param is: 0, the a is: 19818
This is son, the pid is:15748, the param is: 1, the a is: 19819
This is son, the pid is:15747, the param is: 0, the a is: 19820
This is son, the pid is:15748, the param is: 1, the a is: 19821
This is son, the pid is:15747, the param is: 0, the a is: 19822
This is son, the pid is:15748, the param is: 1, the a is: 19823
This is son, the pid is:15747, the param is: 0, the a is: 19824
This is son, the pid is:15748, the param is: 1, the a is: 19825
This is son, the pid is:15747, the param is: 0, the a is: 19826
This is son, the pid is:15748, the param is: 1, the a is: 19827
This is son, the pid is:15747, the param is: 0, the a is: 19828
This is son, the pid is:15748, the param is: 1, the a is: 19829
This is son, the pid is:15747, the param is: 0, the a is: 19830
This is son, the pid is:15748, the param is: 1, the a is: 19831
This is son, the pid is:15747, the param is: 0, the a is: 19832
This is son, the pid is:15748, the param is: 1, the a is: 19833
This is son, the pid is:15747, the param is: 0, the a is: 19834
...
...

结果分析
本示例将子线程的每次累加打印出来，从结果上可以证明上一个示例的推测是正确的，子线程交替并行。

clone31-3Test.c

#define  _GNU_SOURCE 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#include <sched.h>
#include <signal.h>

#include <sys/types.h>
#include <unistd.h>


#define FIBER_STACK 8192
#define CLONE_NUM 5

int a;
void * stacks[CLONE_NUM];


 	int myParams0 = 0 ;
 	int myParams1 = 1 ;
 	int myParams2 = 2 ;
 	int myParams3 = 3 ;
 	int myParams4 = 4 ;
		
int do_something(void *lparam)
{
    int i;
    int j;
    i = (int)lparam;
   
    //int a=0;
    
    for (j=0;j<10000;j++)
       ++a;
    
    printf("This is son, the pid is:%d, the param is: %d, the a is: %d\n", getpid(), i , a);

    free(stacks[i]); //这里我也不清楚，如果这里不释放，不知道子线程死亡后，该内存是否会释放，知情者可以告诉下,谢谢
    exit(1);
}

int do_loop_time()
{
  int i,j,k;
  for (i=0;i<1000;i++)
    for (j=0;j<1000;j++)
      for (k=0;k<1000;k++)
	;
}

int cloneMethod1()
{
		clone(&do_something, (char *)(stacks[myParams0]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams0);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams1]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams1);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams2]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams2);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams3]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams3);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams4]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams4);//创建子线程   

}

int cloneMethod2()
{
    int i;
    for (i=0;i<CLONE_NUM;i++)
    {
		clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}

int cloneMethod3()
{
    int i;
    
    pid_t parentPID = getpid();
    pid_t myPID;
    for (i=0;i<CLONE_NUM;i++)
    {
		myPID = getpid();
		if (myPID == parentPID)
			clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}



int main()
{
    int i;
    a =0;
    
    for (i=0;i<CLONE_NUM;i++)
    {
	stacks[i] = malloc(FIBER_STACK);//为子进程申请系统堆栈   
        if(!stacks[i])
        {
			printf("The stack failed\n");
			exit(0);
	    }
    }


    printf("creating son thread!!!\n");
    cloneMethod1();

    
    char ch;
    scanf("%c",&ch);
    
    printf("This is father, my pid is: %d, the a is: %d\n", getpid(), a);
    
     for (i=0;i<CLONE_NUM;i++)
    {
//		free(stacks[i]) ;   
    }   
   
    exit(1);
}

输出

 creating son thread!!!
This is son, the pid is:15891, the param is: 1, the a is: 10000
This is son, the pid is:15892, the param is: 0, the a is: 15067
1
This is father, my pid is: 15890, the a is: 15067

结果分析
本示例在子线程运行函数里添加了free及时释放分配的内存空间。按照内存分配的网络资料来看，一个C程序分配内存后如果不free，则会一直占用内存。但程序执行结束后没有free的内存，会随着程序结束free。

clone31-4Test.c

#define  _GNU_SOURCE 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#include <sched.h>
#include <signal.h>

#include <sys/types.h>
#include <unistd.h>


#define FIBER_STACK 8192
#define CLONE_NUM 5

int a;
void * stacks[CLONE_NUM];


 		int myParams0 = 0 ;
 		int myParams1 = 1 ;
 		int myParams2 = 2 ;
 		int myParams3 = 3 ;
 		int myParams4 = 4 ;
		
int do_something(void *lparam)
{
    int i;
    int j;
    i = (int)lparam;
   
    //int a=0;
    
    for (j=0;j<10000;j++)
      printf("This is son, the pid is:%d, the param is: %d, the a is: %d\n", getpid(), i , ++a);
    
    printf("This is son, the pid is:%d, the param is: %d, the a is: %d\n", getpid(), i , a);

    free(stacks[i]); //这里我也不清楚，如果这里不释放，不知道子线程死亡后，该内存是否会释放，知情者可以告诉下,谢谢
    exit(1);
}

int do_loop_time()
{
  int i,j,k;
  for (i=0;i<1000;i++)
    for (j=0;j<1000;j++)
      for (k=0;k<1000;k++)
	;
}

int cloneMethod1()
{
		clone(&do_something, (char *)(stacks[myParams0]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams0);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams1]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams1);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams2]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams2);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams3]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams3);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams4]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams4);//创建子线程   

}

int cloneMethod2()
{
    int i;
    for (i=0;i<CLONE_NUM;i++)
    {
		clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}

int cloneMethod3()
{
    int i;
    
    pid_t parentPID = getpid();
    pid_t myPID;
    for (i=0;i<CLONE_NUM;i++)
    {
		myPID = getpid();
		if (myPID == parentPID)
			clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}



int main()
{
    int i;
    a =0;
    
    for (i=0;i<CLONE_NUM;i++)
    {
	stacks[i] = malloc(FIBER_STACK);//为子进程申请系统堆栈   
        if(!stacks[i])
        {
			printf("The stack failed\n");
			exit(0);
	    }
    }



    printf("creating son thread!!!\n");
    cloneMethod1();
    
    
    char ch;
    scanf("%c",&ch);
    
    printf("This is father, my pid is: %d, the a is: %d\n", getpid(), a);
    
     for (i=0;i<CLONE_NUM;i++)
    {
//		free(stacks[i]) ;   
    }   
    

    exit(1);
}

输出
与31-2Test类似

结果分析
与31-3Test操作相同，将分配的内存及时free。

clone32Test.c

#define  _GNU_SOURCE 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#include <sched.h>
#include <signal.h>

#include <sys/types.h>
#include <unistd.h>


#define FIBER_STACK 8192
#define CLONE_NUM 5

int a;
void * stacks[CLONE_NUM];


 		int myParams0 = 0 ;
 		int myParams1 = 1 ;
 		int myParams2 = 2 ;
 		int myParams3 = 3 ;
 		int myParams4 = 4 ;
		
int do_something(void *lparam)
{
    int i;
    int j;
    i = (int)lparam;
   
    int a=0;
    
    for (j=0;j<10000;j++)
       ++a;
    
    printf("This is son, the pid is:%d, the param is: %d, the a is: %d\n", getpid(), i , a);

    //free(stacks[i]); //这里我也不清楚，如果这里不释放，不知道子线程死亡后，该内存是否会释放，知情者可以告诉下,谢谢
    exit(1);
}

int do_loop_time()
{
  int i,j,k;
  for (i=0;i<1000;i++)
    for (j=0;j<1000;j++)
      for (k=0;k<1000;k++)
	;
}

int cloneMethod1()
{
		clone(&do_something, (char *)(stacks[myParams0]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams0);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams1]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams1);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams2]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams2);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams3]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams3);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams4]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams4);//创建子线程   
}

int cloneMethod2()
{
    int i;
    for (i=0;i<CLONE_NUM;i++)
    {
		clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}

int cloneMethod3()
{
    int i;
    
    pid_t parentPID = getpid();
    pid_t myPID;
    for (i=0;i<CLONE_NUM;i++)
    {
		myPID = getpid();
		if (myPID == parentPID)
			clone(&do_something, (char *)(stacks[i]) + FIBER_STACK, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}



int main()
{
    int i;
    a =0;
    
    for (i=0;i<CLONE_NUM;i++)
    {
	stacks[i] = malloc(FIBER_STACK);//为子进程申请系统堆栈   
        if(!stacks[i])
        {
			printf("The stack failed\n");
			exit(0);
	    }
    }



    printf("creating son thread!!!\n");
    cloneMethod1();
    
    
    char ch;
    scanf("%c",&ch);
    
    printf("This is father, my pid is: %d, the a is: %d\n", getpid(), a);
    
     for (i=0;i<CLONE_NUM;i++)
    {
//		free(stacks[i]) ;   
    }   
    

    exit(1);
}

输出

creating son thread!!!
This is son, the pid is:This is son, the pid is:22435, the param is: 0, the a is: 22436,This is son, the pid is:This is son, the pid is:22435, the param is: 0, the a is: 22436, the param is: 1, the a is: 10000
This is son, the pid is:22439, the param is: 4, the a is: 10000
This is son, the pid is:22438, the param is: 3, the a is: 10000
This is son, the pid is:22437, the param is: 2, the a is: 10000
1
This is father, my pid is: 22434, the a is: 0

结果分析
从输出上可以看出，因为dosomething里将a赋值为0，所以每个输出都是10000。输出也不是按照子线程创建顺序。子线程是分别执行的不同dosomething函数，并且交替并行。

clone33-1Test.c

       #define _GNU_SOURCE
       #include <sys/wait.h>
       #include <sys/utsname.h>
       #include <sched.h>
       #include <string.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>
       #include <sys/mman.h>


#define STACK_SIZE (1024 * 1024) 
#define CLONE_NUM 5

int a;
char * stacks[CLONE_NUM];


 		int myParams0 = 0 ;
 		int myParams1 = 1 ;
 		int myParams2 = 2 ;
 		int myParams3 = 3 ;
 		int myParams4 = 4 ;
		
int do_something(void *lparam)
{
    int i;
    int j;
    i = (int)lparam;
   
    //int a=0;
    
    for (j=0;j<10000;j++)
       ++a;
    
    printf("This is son, the pid is:%d, the param is: %d, the a is: %d\n", getpid(), i , a);

    //free(stacks[i]); //这里我也不清楚，如果这里不释放，不知道子线程死亡后，该内存是否会释放，知情者可以告诉下,谢谢
    exit(1);
}

int do_loop_time()
{
  int i,j,k;
  for (i=0;i<1000;i++)
    for (j=0;j<1000;j++)
      for (k=0;k<1000;k++)
	;
}

int cloneMethod1()
{
		clone(&do_something, (char *)(stacks[myParams0]) + STACK_SIZE, CLONE_NEWUTS | CLONE_SIGHAND, (void *)myParams0);//创建子线程   
		clone(&do_something, (char *)(stacks[myParams1]) + STACK_SIZE, CLONE_NEWUTS | CLONE_SIGHAND, (void *)myParams1);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams2]) + STACK_SIZE, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams2);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams3]) + STACK_SIZE, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams3);//创建子线程   
//		clone(&do_something, (char *)(stacks[myParams4]) + STACK_SIZE, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, (void *)myParams4);//创建子线程   
}

int cloneMethod2()
{
    int i;
    for (i=0;i<CLONE_NUM;i++)
    {
		clone(&do_something, (char *)(stacks[i]) + STACK_SIZE, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}

int cloneMethod3()
{
    int i;
    
    pid_t parentPID = getpid();
    pid_t myPID;
    for (i=0;i<CLONE_NUM;i++)
    {
		myPID = getpid();
		if (myPID == parentPID)
			clone(&do_something, (char *)(stacks[i]) + STACK_SIZE, CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,  (void *)i);//创建子线程   
    }
    
}



int main()
{
    int i;
    a =0;
    
    for (i=0;i<CLONE_NUM;i++)
    {
	stacks[i] = mmap(NULL, STACK_SIZE, PROT_READ | PROT_WRITE,
                     MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0); //为子进程申请系统堆栈   
        if(stacks[i] == MAP_FAILED)
        {
			printf(" mmap The stack failed\n");
			exit(0);
	    }
	 }   

    printf("creating son thread!!!\n");
    cloneMethod1();
    
    
    char ch;
    scanf("%c",&ch);
    
    printf("This is father, my pid is: %d, the a is: %d\n", getpid(), a);
    
     for (i=0;i<CLONE_NUM;i++)
    {
//		free(stacks[i]) ;   
    }   
    

    exit(1);
}

输出

creating son thread!!!
1
This is father, my pid is: 23024, the a is: 0

结果分析
clone的参数为CLONE_NEWUTS ，则在子项中所做的更改无法传播回父项。

anonfish
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c 语言getpid头文件,c – 需要当前进程的PID,getpid()返回-1
weixin_39623350的博客
05-23 1400
我需要为进程使用的文件(执行我的C程序)提供一个唯一的名称.在我使用静态字符串之前,但当我尝试并行运行程序的两个实例时,我意识到它们都访问了同一个文件.为此,我希望文件名包含创建和使用它的进程的PID.但是,当我尝试使用getpid()时,我似乎总是得到-1作为返回值.void accessfile(){std::cout << "DEBUG: accessfile() called ...
Linux中的clone()函数
weixin_33978044的博客
11-06 212
int clone(int (*fn)(void *), void *child_stack, int flags, void *arg); 这里fn是函数指针，我们知道进程的4要素，这个就是指向程序的指针，就是所谓的“剧本", child_stack明显是为子进程分配系统堆栈空间（在linux下系统堆栈空间是2页面，就是8K的内存，其中在这块内存中，低地址上放入了值，这个值就是进程控制块tas...
Linux Clone函数
ting2909的博客
01-18 1338
从linux 2.3.3开始，glibc的fork()封装作为NPTL(Native POSIX Threads Library)线程实现的一部分。直接调用fork()等效于调用clone(2)时仅指定flags为SIGCHLD(共享信号句柄表)。 创建线程的函数pthread_create内部使用的也是clone函数。在glibc的/sysdeps/unix/sysv/linux/createthread.c源码中可以看到，创建线程的函数create_thread中使用了clone函数，并指定了相关的fl
Linux Kernel ‘CLONE_NEWUSER|CLONE_FS’本地权限提升漏洞
weixin_30888027的博客
03-15 286
漏洞名称： Linux Kernel ‘CLONE_NEWUSER|CLONE_FS’本地权限提升漏洞 CNNVD编号： CNNVD-201303-281 发布时间： 2013-03-15 更新时间： 2013-03-15 危害等级： 漏洞类型： 权限许可和访问控制 威胁类型： 本地...
fork()、vfork()、clone()的区别
行而不辍，未来可期 - King
05-07 1万+
因为生活的复杂，这是一个并行的世界， 在同一时刻，会发生很多奇妙的事情，北方下雪，南方下雨，这里在吃饭，那边在睡觉，有人在学习，有人在运动，所以这时一个 多彩多姿的世界，每天都发生着很多事情，所以要想很好的表现这个世界，协调完成一件事儿，就得用到多进程或者多线程。 所以进程是程序猿一定会接触到的一个东西，他能使我们的程序效率提高，高效的完成多任务，并行执行。
Linux内核分析与应用课件第3章（二）进程的创建.pdf
01-01
"Linux内核分析与应用课件第3章（二）进程的创建" 本课件主要介绍了Linux系统中进程的创建机制，包括进程和线程的概念、创建过程、task_struct结构的统一性等。 首先，进程和线程都是系统资源分配的基本单位，但...
Linux内核分析与应用课件第4章（二）进程用户空间管理机制.pdf
最新发布
01-01
对于`clone()`函数创建的内核线程，它们通常会共享父进程的用户空间，而不需要额外创建。 “写时复制”（Copy-on-Write，COW）是Linux快速创建进程的关键技术。在COW机制下，子进程初始时与父进程共享同一份物理...
Linux内核源代码情景分析 (上下册 高清非扫描 )
03-27
第2章 存储管理 2.1 Linux内存管理的基本框架 2.2 地址映射的全过程 2.3 几个重要的数据结构和函数 2.4 越界访问 2.5 用户堆栈的扩展 2.6 物理页面的使用和周转 2.7 物理页面的分配 2.8 页面的定期换出 2.9 页面的换...
Linux下多线程编程-Pthread与Semaphore的使用.doc
10-10
第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。pthread_join 函数的原型为：extern int pthread_join __P ((pthread_t __th,...
linux内核源代码情景分析
05-04
《linux内核源代码情景分析》（非扫描电子版本） 第1章　预备知识 1.1 Linux内核简介 1.2 Intel X86 CPU系列的寻址方式 1.3 i386的页式内存管理机制 1.4 Linux内核源代码中的C语言代码 1.5 Linux内核源代码中的...
linux clone函数使用
冰雪的专栏
12-19 3711
Linux 上创建线程一般使用的是 pthread 库  实际上 libc 也给我们提供了创建线程的函数  那就是 clone        int clone(int (*fn)(void *), void *child_stack,                  int flags, void *arg, ...                  /* pid_t *ptid, s
操作系统 基于clone()系统调用
scl512的专栏
11-09 2420
 #include "sched.h"#include "pthread.h"#include "stdio.h"#include "stdlib.h"#include "semaphore.h"#include "string.h"int producer(void *args);int consumer(void *args);pthread_mutex_t mutex ;      //
Linux下编程为什么多用进程少用线程
10-27 624
Linux下编程为什么多用进程少用线程 Linux内核中线程的实现-Linux下编程为什么多用进程少用线程之二一、Linux内核对多进程和多线程的支持方式Linux的线程实现是在核外进行的，核内提供的是创建进程的接口do_fork()。内核提供了两个系统调用__clone()
进程管理(八)--创建进程fork
奇小葩
05-17 1448
在最新的版本的POSIX标准中，定义了进程创建和终止的操作，进程创建包括fork()和execve()，进程终止包括wait()，waitpid()，kill()以及exit()。Linux系统为了提高效率，把POSIX标准的fork()扩展为vfork和clone。 前面一章我们学习了用GCC将一个最简单的程序(如hello world程序)编译成ELF文件，在shell提示符下输入该可执行文件并且按回车后，这个程序就开始执行了。起始这里shell会调用fork()来创建一个新进程，然后调用execve(
解决方案:Linux 下使用clone()函数 ,编译后出现CLONE_VM未定义的错误
wck0617
08-30 5592
在使用clone函数时,需要在代码的开始(顶部)处引入一个宏和头文件,如下 #define _GNU_SOURCE /*注意摆放位置*/ #include &lt;sched.h&gt; /*注意摆放位置*/ #include&lt;sys/types.h&gt; #include&lt;sys/syscall.h&gt; #include&lt;unistd.h...
linux的Clone()函数详解
Jack小站
04-04 2万+
int clone(int (*fn)(void *), void *child_stack, int flags, void *arg); LinuxClone()函数详解 这里fn是函数指针，我们知道进程的4要素，这个就是指向程序的指针，就是所谓的“剧本", child_stack明显是为子进程分配系统堆栈空间（在Linux下系统堆栈空间是2页面，就是8K的内存，其中在这块内存中，低地址上放入了值，这个值就是进
Linux中fork，vfork和clone详解（区别与联系）
热门推荐
OSKernelLAB(gatieme)
05-15 6万+
fork，vfork，cloneUnix标准的复制进程的系统调用时fork（即分叉），但是Linux，BSD等操作系统并不止实现这一个，确切的说linux实现了三个，fork,vfork,clone（确切说vfork创造出来的是轻量级进程，也叫线程，是共享资源的进程） 系统调用 描述 fork fork创造的子进程是父进程的完整副本，复制了父亲进程的资源，包括内存的内容task_str
Linux clone函数
05-27
Linux clone()函数是一个系统调用，可以用于创建一个新进程，可以选择共享或独立进程的内存空间、文件描述符、信号处理等资源。它与fork()函数类似，但是可以更灵活地控制新进程的创建。使用clone()函数需要指定一个函数作为新进程的入口点，并将该函数的参数传递给它。此外，clone()函数还可以指定新进程的标志位，用于控制新进程与父进程之间的共享或独立关系。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值