Linux操作系统入门--线程管理

1.进程与线程

进程是操作系统分配资源的单位，线程是操作系统调度的单位；

每个进程都有自己的数据段、代码段、堆栈段，线程在内存空间共享一个进程资源；

线程间彼此切换所需的时间远远小于进程间彼此切换，所以称线程为轻量级进程。

2.线程创建函数pthread_create()

函数原型：

              int  pthread_create（（pthread_t  *tid,  pthread_attr_t  *attr,  void  *（*start_routine）（void  *）,  void  *arg）

参数说明：

              tid：  所要创建的子线程标识符；

              attr：线程属性设置；

              start_routine：线程函数的起始地址，即子线程调用的函数

              arg：传递给start_routine的参数；

返回值说明：

              创建成功，返回0；出错，返回-1。

函数使用说明：

             调用该函数，创建子进程，创建成功的子进程将进入start_routine()函数中执行

3.线程挂起函数pthread_join()

函数原型：
                  int pthread_join(pthread_t thread, void **retval);

参数说明：
                    thread: 等待线程的 标识符，即线程ID；
                    retval: 用户定义的指针，用来存储被等待线程的返回值。

返回值说明：
                   0代表成功。 失败，返回的则是错误号。

使用说明 ：
                   pthread_join()函数，使一个线程等待另一个线程结束。即以阻塞的方式等待thread指定的线程结束。
                  当函数返回时，被等待线程的资源被收回。                
                  代码中如果没有pthread_join主线程会很快结束从而使整个进程结束，从而使创建的线程没有机会开始执行就结束了。
                  加入pthread_join后，主线程会一直等待直到等待的线程结束自己才结束，使创建的线程有机会执行。

4.线程结束函数pthread_exit()

函数原型：
                void  pthread_exit（void  *retval）
参数说明：
                 线程结束后返回值存入retval中

5.其他函数

pthread_self()；     返回线程的

syscall(SYS_gettid)；  返回线程的pid

6.示例一

<span style="font-size:12px;"># include <sys/types.h>
# include <sys/syscall.h>
# include<stdio.h>
# include<pthread.h>
# include<stdlib.h>
# include<unistd.h>

int counter=0;
void thread1 (int * counter)
{
printf("the main thread:%d\n",getpid());
printf("now,thread1 :%lu\n",pthread_self());
printf("thread1 :%ld\n", syscall(SYS_gettid));
int num=5;
while(num>0)
{
printf("thread1 count:%d\n ",*counter);
(* counter)++;
num--;
sleep(2);
}
}

void thread2 (int * counter)
{
printf("the main thread:%d\n",getpid());
printf("now,thread2 :%lu\n",pthread_self());
printf("thread2: %ld\n", syscall(SYS_gettid));
int num=5;
while(num>0)
{
printf("thread2 count:%d\n ",*counter);
(* counter)++;
num--;
sleep(2);
}
}


int main(void)
{
pthread_t thrd1,thrd2;
int ret;

printf("process pid :%d\n",getpid());
printf("the main thread:%lu\n",pthread_self());
printf("%ld\n", syscall(SYS_gettid));

ret=pthread_create(&thrd1,NULL,(void *)thread1,(void *)&counter);
if(ret==0)
{
printf("pthread1 success\n");
}

else if(ret==-1)
{
printf("pthread1 failed\n");
exit(1);
}

printf("main\n");
printf("%lu\n",thrd1);
ret=pthread_create(&thrd2,NULL,(void *)thread2,(void *)&counter);
if(ret)
{
printf("pthread2 failed\n");
exit(1);

}
else
 printf("pthread2 success\n");
printf("main\n");
printf("%lu\n",thrd2);
pthread_join(thrd2,NULL);   //等待子线程2
pthread_join(thrd1,NULL);   //等待子线程1
printf("end, %lu\n",thrd1);
printf("thread1 and thread2 has exit\n");
printf("counter :%d\n",counter);
return 0;
}</span>
              

7. 示例二

<span style="font-size:12px;">/* 
* POSIX 下线程控制的实验程序完整版 1.2 7 */

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <ctype.h>
#include <pthread.h>

#define MAX_THREAD 3 /* 线程的个数 */
/**/
unsigned long long main_counter, counter[MAX_THREAD]; /* unsigned long long是比long还长的整数 */
void* thread_worker(void*);

int main(int argc, char* argv[])
{
int i, rtn, ch;
pthread_t pthread_id[MAX_THREAD] = {0}; /* 存放每个线程的id */
for (i=0; i<MAX_THREAD; i++)
{
/*pthread_create建一个普通的线程，
* 线程id存入pthread_id[i]，
* 线程执行的函数是thread_worker，并i作为参数传递给线程 */
pthread_create(&pthread_id[i],NULL,(void *)thread_worker,(void *)&i);
sleep(1);
}
/* 用户按一次回车执行下面的循环体一次。按q退出 */

do
{
unsigned long long sum = 0;
/* 求所有线程的counter的和 */
for(i=0; i<MAX_THREAD; i++)
{
sum += counter[i];
printf("counter[%d]:%llu   ",i, counter[i]);

}
printf("main_counter:%llu, sum:%llu\n", main_counter, sum);
}
while ((ch = getchar()) != 'q');
return 0;
}
void* thread_worker(void* p)
{
int thread_num;
thread_num=*(int *)p;
printf("thread %d\n",thread_num);
for(;;) /* 无限循环 */
{
counter[thread_num]++; /* 本线程的counter加一 */
main_counter++; /* 主counter 加一 */
}
}</span>