【线程】线程创建 | 理解线程并发 （1）_pthread_create调度策略

• 线程并发，线程安全（面试，什么是线程安全）
• 线程同步（代码体现）
  线程概念：进程内部的一条执行路径
  进程概念：一个正在运行的程序
  线程属性一般给空
  子线程和主线程同时进行。（又叫 并发运行）
  pthread_create(&id,NULL.thread_fun,NULL)
  给thread_fun传入的参数为NULL
  一般都是线程函数先结束，main函数后结束（因此pthread_exit() 写在线程函数中）
  如果线程想先退出你调用pthread_exit()，而不是进程退出。
• pthread_create()用于创建线程

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

//thread： 接收创建的线程的 ID
//attr： 指定线程的属性 （一般传空）
//start_routine： 指定线程函数
//arg： 给线程函数传递的参数
//成功返回 0， 失败返回错误码
1
2
3
4
5
6
7

• pthread_exit()退出线程

//retval：指定退出信息
 int pthread_exit(void *retval);
1
2

• pthread_join()等待 thread 指定的线程退出，线程未退出时，该方法阻塞

//retval：接收 thread 线程退出时，指定的退出信息
int pthread_join(pthread_t thread, void **retval);
1
2

引用线程 头文件#include<pthread.h>

#include<pthread.h>

//一般都是让线程函数先结束，main函数后结束
void* thread_fun(void* arg)   //子线程和主线程同时进行
	{
	for (int i = 0; i < 5; i++)
	{
		printf("hello fun \n");  //由于子线程运行太快，没来的及打印就结束了。
        sleep(1);//让其打印满下来，才能感知到子线程和主线程在同步执行
	}
	}
//线程正常结束是不会退出进程的，因为没有调用exit
int main()  //main函数结束，不论写不写exit，系统会调用exit退出
{   
	pthread_t id; //线程id
	pthread_create(&id, NULL, thread_fun, NULL);
	for (int i = 0; i < 5; i++)
	{
		printf("hello main\n");
        sleep(1);
	}
    exit(0);//退出进程
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

包括两个for循环及以后的代码，是同时执行的。
编译：gcc -o thread thread.c -lpthread 后面要加上线程库

运行：

• 进一步理解

int data = 2;
//一般都是让线程函数先结束，main函数后结束
void* thread_fun(void* arg)   //子线程和主线程同时进行
	{
	for (int i = 0; i < 5; i++)
	{
		printf("hello fun \n");  //由于子线程运行太快，没来的及打印就结束了。
       sleep(1);//让其打印满下来，才能感知到子线程和主线程在同步执行
    }
  //  pthread_exit("fun exit");
	   pthread_exit(&data);
    //  pthread_exit(NULL);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

//线程正常结束是不会退出进程的，因为没有调用exit

int main()  //main函数结束，不论写不写exit，系统会调用exit退出
{   
	pthread_t id; //线程id
	pthread_create(&id, NULL, thread_fun, NULL);
	for (int i = 0; i < 2; i++)
	{
		printf("hello main\n");
        sleep(1);
	}
1
2
3
4
5
6
7
8
9

pthread_join(id,(void**)&p);//这个位置是可以将全局变量，静态变量，传递出去的也可以什么都不写，返回NULL，等待线程结束

    char *s = NULL;//修改指针变量指向fun exit
     int*p= NULL;
   // pthread_join(id,(void**)&s);//运行到这，会阻塞3秒钟，等待线程结束
     pthread_join(id,(void**)&p);//这个位置是可以将全局变量，静态变量，传递出去的也可以什么都不写，返回NULL，等待线程结束
    //  pthread_join(id,NULL);
   // printf("join s = %s\n",s);
     printf("data %d",*p);
     exit(0);//退出进程
}
1
2
3
4
5
6
7
8
9

• 什么都不传pthread_join(id,NULL);
  

• 传出全局变量
  int*p= NULL;
pthread_join(id,(void**)&p);
printf("data %d",*p);
  

• 创建多个线程
  int* = &i;
*arg = i;
int idex = *(int*)arg;
  5个线程，谁跑的块谁跑的慢，无法控制，所要要保证传入的值，可以不受其影响。
  （通过，sleep(),和传值控制）

5个线程，谁先创建，和谁先执行无关，关系到进程的调度，线程的调度。
并行 ：拥有一个以上的cpu，多个进程同时执行，（每个cpu处理多个可并发的程序）
并发：多个进程在同一时间，间隔执行（分时交替执行）

#include<pthread.h>

void* fun(void *arg)//线程启动慢，在主线程已经跑到i变为三的时候，创建的第一个线程才获得当前的i值3，后面的线程获的值可能是3，只要在主线程未更新i之前，也有可能主线程已经执行到i=4，前面创建的线程才启动，得到的值自然也就都是4
{
  
 //       int index = *(int*)arg;//   *arg = i
       int index = (int)arg;
        printf("index =%d\n",index);
}
int main()
{
        pthread_t id[5];
        int i = 0;
        for(int i = 0;i<5;i++)
        {
               // pthread_create(&id[i],NULL,fun,&i);//给线程函数传入的是i的地址，需要arg去通过i的地址找到其空间中的值，因此找到的值可能已经被更新，已经不是要给它的值。
              pthread_create(&id[i],NULL,fun,(void*)i);
                                              //直接将i当前的值传给arg，不存在寻地址，也不存在i是否更新。传入的值是多少，打印的就是多少，如果传入的是地址，线程函数启动的慢，再去访问i的地址空间中的值，就是随机的了。
               // sleep(1);
        }
        for(int i =0;i<5;i++)
        {
               pthread_join(id[i],NULL); //传入的是i的地址
        }
        exit(0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

• pthread_create(&id[i],NULL,fun,&i);
  给线程函数传入的是i的地址，需要arg去通过i的地址找到其空间中的值，因此找到的值可能已经被更新，已经不是要给它的值。
• pthread_create(&id[i],NULL,fun,(void*)i);
  直接将i当前的值传给arg，不存在寻地址，也不存在i是否更新。传入的值是多少，打印的就是多少，如果传入的是地址，线程函数启动的慢，再去访问i的地址空间中的值，就是随机的了。