lunux多线程编程

1.进程与线程

　　1）用户空间角度：

　　进程：fork()创建进程，在创建时，重新申请了内存空间，copy了父进程的所有信息。

　　线程：pthread_create()创建进程时，只申请自己的栈空间。

　　2）内核空间：

　　对内核空间，两者都有自己的pid，因此内核空间不区分。

2.基本函数：

　　1）创建线程：

　　#include <pthread.h>

　　extern in t pthread_create（pthread_t *tidp,const pthread_attr_t *attr,(void*)(*start_rtn)(void*),void  *arg）

　　第1个参数： 线程id

　　第2个参数：用来设置线程属性，通常为NULL

　　第3个参数：需要创建线程的执行代码地址

　　第4个参数：线程执行参数

　　pthread.h支持的是POSIX,编译时加－lpthread

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/syscall.h>
struct data{
        int i;
        int j;
};
void *hello(struct data *str)
{
        printf("child,  the tid=%lu, pid=%ld\n",pthread_self(),syscall(SYS_gettid));
        printf("arg.i=%d\narg.j=%d \n",str->i,str->j);
        sleep();
}

int main(int agrc,char *agrv[])
{
        struct data test;
        pthread_t thread_id;
        test.i=;
        test.j=;
        pthread_create(&thread_id,NULL,(void*)*hello,&test);
        printf("parent, the tid=%lu,pid=%ld\n",pthread_self(),syscall(SYS_gettid));
        pthread_join(thread_id,NULL);
}

　　2)线程退出：

　　extern void pthread_exit(void *_retval),参数为线程取消状态。

　　int pthread _cancel(pthread_t thread)

　　线程取消的清理：

　　int pthread_cleanup_push(void (*routine)(void*),void *arg)

　　int pthread_cleanup_pop(int execute)

 #include<pthread.h>
 #include<unistd.h>
 #include<stdlib.h>
 #include<stdio.h>

 void cleanup()
 {
         printf("cleanup\n");
 }
 void *test_cancel(void)
 {
         pthread_cleanup_push(cleanup,NULL);
         printf("test_cancel\n");
         while()
         {
                 printf("test message\n");
                 sleep();
         }
         pthread_cleanup_pop();
 }
 int main()
 {
         pthread_t tid;
         pthread_create(&tid,NULL,(void *)test_cancel,NULL);
         sleep();
         pthread_cancel(tid);
         pthread_join(tid,NULL);   // pthread_join()等待线程执行
 }

　　3）线程与私有数据：

　　int pthread_key_create(pthread_key_t *key, void (*destructor)(void*))   //创建私有数据

　　int pthread_key_delete(pthread_key_t key)  //删除私有数据

　　int pthread_setspecific(pthread_key_t key,const void *pointer)  //读，pointer是与key相关联的

　　int pthread_getspecific(pthread_key_t key)  //写

3.互斥锁：以排他的方式防止共享数据并发的访问

　　1）初始化：

　　#include <pthread.h>

　　int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr)

　　第1个参数：所要指向的互斥锁指针

　　第2个参数：指向属性对象的指针，如NULL使用默认属性

　　2）申请互斥锁：

　　int pthread_mutex_lock(pthread_mutex_t  *mutex)       //阻塞方式申请

　　int pthread_mutex_trylock(pthread_mutex_t  *mutex)  //非阻塞方式申请

　　3）释放互斥锁：

　　int pthread_mutex_unlock(pthread_mutex_t  *mutex)

 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <semaphore.h>
 #include <string.h>

 void *thread_function(void *arg);

 pthread_mutex_t work_mutex;

 #define WORK_SIZE 1024
 char work_area[WORK_SIZE];
 int time_to_exit = ;

 int main(int argc,char *argv[])
 {
     int res;
     pthread_t a_thread;
     void *thread_result;
     res = pthread_mutex_init(&work_mutex, NULL); //init mutex
     if (res != )
         {
         perror("Mutex initialization failed");
         exit(EXIT_FAILURE);
     }
     res = pthread_create(&a_thread, NULL, thread_function, NULL);//create new thread
     if (res != )
         {
         perror("Thread creation failed");
         exit(EXIT_FAILURE);
     }
     pthread_mutex_lock(&work_mutex);                    //lock the mutex
     printf("Input some text. Enter 'end' to finish\n");
     while(!time_to_exit)
         {
         fgets(work_area, WORK_SIZE, stdin);             //get a string from stdin
         pthread_mutex_unlock(&work_mutex);              //unlock the mutex
         while()
                 {
             pthread_mutex_lock(&work_mutex);    //lock the mutex
             if (work_area[] != '\0')
                         {
                 pthread_mutex_unlock(&work_mutex);      //unlock the mutex
                 sleep();
             }