Linux 操作系统学习之线程

Linux在用fork创建进程时，为子进程申请了堆栈、BSS区、全局变量、和代码段等资源。而用pthread_create创建线程时，用户空间分配的资源比线程少得多。可以说，线程就是轻量级的进程。

1.函数 pthread_create()用来创建一个新的线程。其函数声明如下：

/*come from /usr/include/pthread.h*/
extern int pthread_create (pthread_t *__restrict __newthread,
               __const pthread_attr_t *__restrict __attr,
               void *(*__start_routine) (void *),
               void *__restrict __arg) __THROWNL __nonnull ((1, 3));

第一个参数用来存储线程的ID，参数为指向线程ID的指针。创建成功，返回新线程ID；_restrict 是C99定义的新标准关键字，主要用来提高编译效率。

第二个参数用来设置线程属性，主要设置与栈相关的属性。一般情况下，此参数设置为NULL，新的线程将使用系统默认的属性。

第三个参数是线程运行的代码起始地址。

第四个参数是运行函数的参数地址，如果需要传入多个参数，需要使用结构体。

 

示例：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>

struct message
{
    int i;
    int j;
};

void *hello (struct message *str);

int main(int argc, char* argv[])
{
    struct message test;
    pthread_t thread_id;
    test.i = 10;
    test.j = 20;
    /*create thread*/
    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);
    sleep(1);
    return 0;
}

void *hello (struct message *str)
{
    printf("child, the tid = %lu, pid = %ld\n",pthread_self(),syscall(SYS_gettid));
    printf("the arg.i is %d, arg.j is %d\n",str->i, str->j);
}

 2.线程的退出和等待：

线程的退出函数声明如下：

extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));

此函数只有一个参数，即线程退出状态。

等待线程：

为了同步线程，一般主线程都会等待子线程结束，显式的等待某线程结束。可以调用pthread_join实现。其函数声明如下：

extern int pthread_join (pthread_t __th, void **__thread_return);

第一个参数是被等待的线程的ID，第二个参数为用户定义的指针，指向一个保存等待线程的完整退出状态的静态区域，它可以用来存储被等待线程的返回值。

线程的独立：

如果要设置某个线程为独立线程，则可以调用pthread_detach实现。声明如下：

extern int pthread_detach (pthread_t __th) 

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>

void *helloworld(char* arg);

int main(int argc, char* argv[])
{
    int error;
    int *temptr;
    pthread_t thread_id;
    /*create thread*/
    pthread_create(&thread_id,NULL,(void)helloworld,"hello,world");
    printf("*p = %u, p = %u\n",(unsigned int)*helloworld,(unsigned int) helloworld);
    
    /*wait for child thread terminating*/
    pthread_join(thread_id,(void **)&temptr);

    printf("temp = %x, *temp = %c\n",(unsigned)temptr,*temptr);
    *temptr = 'd';
    printf("%c\n",*temptr);
    free(temptr);
    return 0;
}

void *helloworld(char *arg)
{
    int *p;
    p = (int*)malloc(10*sizeof(int));
    printf("the message is %s\n",arg);
    printf("the child id is %u\n",pthread_self());
    memset(p,'c',10);
    printf("p = %x\n",(unsigned)p);
    /*thread exit*/
    pthread_exit(p);
}

3.线程退出前的操作
线程的终止会存在资源释放的问题。经常出现的情形：线程为了访问临界资源而为其上锁，但访问过程中该线程被取消，如果线程响应取消，那么临界资源得不到释放。pthread_cleanup_push()/pthread_cleanup_pop()函数用来自动释放资源。其声明如下：

void pthread_cleanup_push(routine, arg)
void pthread_cleanup_pop(execute)

当线程退出时，可以先执行线程处理程序。

示例代码：

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

void cleanup()
{
    printf("clean up\n");
}

void *test_cancel(void)
{
    pthread_cleanup_push(cleanup,NULL);
    printf("test_cancel\n");
    while(1)
    {
        printf("test message\n");
        sleep(1);
    }
    pthread_cleanup_pop(1);
}

int main()
{
    pthread_t tid;
    pthread_create(&tid,NULL,(void*)test_cancel,NULL);
    sleep(4);
    pthread_cancel(tid);
    pthread_join(tid,NULL);
    return 0;
}

4.取消线程：

函数声明：

/* Cancel THREAD immediately or at the next possibility.  */
extern int pthread_cancel (pthread_t __th);

pthread_cancel 函数请求取消线程。只有当目标线程为可取消状态为PTHREAD_CANCEL_ENABLE时，才可被取消。执行取消操作时，将调用线程的取消清理处理程序(pthread_cleanup_push函数)。而pthread_cancel 的调用者不会等待目标线程操作完成。

设置可取消状态：

pthread_setcancelstate()和pthread_setcanceltype()可以用来设置和查询当前线程的可取消性状态或类型。函数声明分别如下：

/* Set cancelability state of current thread to STATE, returning old
   state in *OLDSTATE if OLDSTATE is not NULL.  */
extern int pthread_setcancelstate (int __state, int *__oldstate);

/* Set cancellation state of current thread to TYPE, returning the old
   type in *OLDTYPE if OLDTYPE is not NULL.  */
extern int pthread_setcanceltype (int __type, int *__oldtype);

对于pthread_setcancelstate，该函数有两个参数，state是要设置的新的状态；oldstate用来存储原来的状态。state的值有：

PTHREAD_CANCEL_DISABLE，除非该线程修改自己的状态，否则不可被取消

PTHREAD_CANCEL_ENABLE，这是默认值。

设置取消类型：

有两个参数：

PTHREAD_CANCEL_ASYNCHRONOUS：可随时执行取消请求。

PTHREAD_CANCEL_DEFFERED： 在取消点取消。

线程取消的示例：

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

void *thread_function(void *arg);

int main(int argc, char* argv[])
{
    //int res;
    pthread_t a_thread;
    void *thread_result;
    pthread_create(&a_thread,NULL,thread_function,NULL);
    sleep(1);
    printf("cancelling thread...\n");
    pthread_cancel(a_thread);
    printf("wait for thread to finish...\n");
    pthread_join(a_thread,&thread_result);
    return 0;
}

void *thread_function(void *arg)
{
    int i;
    //sleep(1);
    /*set cancel state as disable*/
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
    sleep(3);
    printf("thread cancel type is disable cannot cancel this thread\n");
    
    for(i = 0;i<3;i++)
    {
        printf("thread is running (%d)...\n",i);
        sleep(1);
    }
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
    printf("Now the cancel state is enable\n");
    sleep(200);
    pthread_exit(0);
}

5.线程与私有数据

　　5.1

在多线程程序中，全局变量为所有线程所共享。但有时有必要提供线程私有的全局变量。实现的方法是使用同名却不同内存地址的线程数据结构。这样的数据结构可以由Posix线程库维护，成为线程私有数据TSD(Thread-specific Data)。

创建、注销线程私有数据：

extern int pthread_key_create (pthread_key_t *__key,
                   void (*__destr_function) (void *))

该函数从TSD池中分配一项，将其地址赋值给key供以后使用。如果第二个参数不是空，在线程退出时将以key所提供的数据作为参数调用其指向的资源释放函数，以释放分配的缓冲区。

用pthread_key_create()创建的key都是所有线程可以访问的，但是各个线程可以根据自己的需要修改key，而不影响其他线程的key值。

注销一个TSD：

extern int pthread_key_delete (pthread_key_t __key)

读写线程的私有数据：

extern int pthread_setspecific (pthread_key_t __key,
                __const void *__pointer)
extern void *pthread_getspecific (pthread_key_t __key)

pthread_setspecific将pointer的值与key关联。

pthread_getspecific 将key与相关连的数据读出，数据类型设为void*因此可以指向任何类型。

应用示例：

全局变量，数据共享

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

int key = 100;

void *helloworld_one(char* arg);
void *helloworld_two(char* arg);

int main(int argc, char* argv[])
{

    pthread_t thread_id_one;
    pthread_t thread_id_two;
    pthread_create(&thread_id_one,NULL,(void*)helloworld_one,"hello,world one");
    pthread_create(&thread_id_two,NULL,(void*)helloworld_two,"hello,world two");
    pthread_join(thread_id_one,NULL);
    pthread_join(thread_id_two,NULL);
    return 0;
}

void *helloworld_one(char *arg)
{
    printf("this is thread one, the arg is %s\n",arg);
    printf("the key is %d\n",key);
    key++;
    printf("now the key++ has been excuted\n");
    pthread_exit(0);
}
void *helloworld_two(char *arg)
{
    sleep(1);
    printf("this is thread two, the arg is %s\n",arg);
    printf("the key is %d\n",key);
    pthread_exit(0);
}

全局变量,私有数据

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

pthread_key_t key;/*线程私有数据类型*/

void echomsg(void *t)
{
    printf("destructor excuted in thread %u, param = %u\n",pthread_self(),((int*)t));
}
void *child_one(void *arg)
{
    int i = 10;
    int tid = pthread_self();
    printf("set key value %d in thread %u\n",i,tid);
    /*modify the value of key*/
    pthread_setspecific(key,&i);
    /*等待线程二修改值*/
    printf("thread one sleep 2 until thread two finish\n");
    sleep(2);
    /*print the current value of the thread*/
    printf("thread %u return %d, add is %u\n",tid, *((int*)pthread_getspecific(key)),(int*)pthread_getspecific(key));    
}
void *child_two(void *arg)
{
    int i = 20;
    int tid = pthread_self();
    printf("set key value %d in thread %u\n",i,tid);
    /*modify the value of key*/
    pthread_setspecific(key,&i);
    printf("thread two sleep 1 \n");
    sleep(1);
    /*print the current value of the thread*/
    printf("thread %u return %d, add is %u\n",tid, *((int*)pthread_getspecific(key)),(int*)pthread_getspecific(key));    
}
int main(void)
{
    pthread_t tid1,tid2;
    pthread_key_create(&key,echomsg);
    pthread_create(&tid1,NULL,(void*)child_one,NULL);    
    pthread_create(&tid2,NULL,(void*)child_two,NULL);
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_key_delete(key);
    return 0;
}