码迷,mamicode.com
首页 > 编程语言 > 详细

【linux高级程序设计】(第十二章)Linux多线程编程

时间:2015-07-30 16:53:07      阅读:198      评论:0      收藏:0      [点我收藏+]

标签:

线程与进程对比

1.用户空间对比

技术分享

2.内核空间资源对比

在创建线程时,Linux内核仍然创建一个新的PCB来标识这个线程。内核并不认为进程与线程有差别。

进程是操作系统管理资源的基本单元,线程时Linux系统调度的基本单元。

3.进程线程函数对比

技术分享

 

创建线程

int pthread_create (pthread_t *__restrict __newthread,

          __const pathread_attr_t *__restrict __attr,

          void *(*__start_routine) (void *),

                              void *__restrict __arg)

技术分享

成功返回0,失败返回非0值。

#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)
{
    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);
    while(1);
}

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

注意,编译的时候需要加上 -lpthread 

gcc -o 名字 源文件 -lphtread  (无法使用perror打印错误信息,因为不修改系统全局变量errno)

技术分享

 

 

void pthread_exit (void *__retval) :线程退出,与exit()函数类似

技术分享

 

int pthread_join (pthread_t __th, void **__thread_return) :阻塞调用当前线程的线程,直到此线程退出。类似于wait函数。

第一个参数:被等待线程ID。必须等待关联线程

第二个参数:用户定义指针,存储被等待线程返回值。

 

int pthread_detach (pthread_t __th) :设置线程为独立线程。成功返回0.

 

测试线程退出时全局变量和堆变量:仍然可用

#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void *helloworld(char *argc);
int main(int argc, char *argv[])
{
    int error;
    int *temptr;
    pthread_t thread_id;
    pthread_create(&thread_id, NULL, (void *)*helloworld, "helloworld");
    //测试下面两者是否有区别
    printf("*p = %x, p = %x\n", *helloworld, helloworld);
    if(error = pthread_join(thread_id, (void**)&temptr))
    {
        perror("pthread_join");
        exit(EXIT_FAILURE);
    }
    //打印子线程退出时的值
    printf("temp = %x, *temp = %c\n", temptr, *temptr);
    //修改堆空间 测试是否可用
    *temptr = d;
    printf("%c\n", *temptr);
    free(temptr);
    return 0;
}

void *helloworld(char *argc)
{
    int *p;
    p = (int *)malloc(10 * sizeof(int));
    printf("the message is %s\n", argc);
    printf("the child id is %u\n", pthread_self());
    memset(p, c, 10);
    printf("p = %x\n", p);
    pthread_exit(p);  //退出线程,堆空间首地址做为返回信息
}

技术分享

可以看到,函数名 helloworld 和 *helloworld 是一样的。

 

线程退出时资源释放

void pthread_cleanup_push(void (*routine) (void *), void *arg) :压入清理函数栈,后进先出

void pthread_cleanup_pop(int execute) :参数为0,表示不执行弹出的清理函数;非0执行。

#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(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(2);
    //取消子线程
    pthread_cancel(tid);
    pthread_join(tid, NULL);
}

技术分享

 

取消线程

条件1:线程必须可以被其他线程取消,默认可以

条件2:线程处于可取消点才能被取消。

int pthread_cancel (pthread_t __cancelthread) :向某线程发送取消操作。

int pthread_setcancelstate (int __state, int *__oldstate) :设置当前线程的可取消性, state为新状况,oldstate存储原来的状态。

  PTHREAD_CANCEL_DISABLE为不可取消;

  PTHREAD_CANCEL_ENABLE为可取消。(默认值)

int pthread_setcanceltype (int __type, int *__oldtype) :设置取消类型。

  PTHREAD_CANCEL_ASYNCHRONOUS :可随时执行新的或未决的取消请求

  PTHREAD_CANCEL_DEFERRED :在目标线程到达取消点之前,取消请求处于未决状态。(默认值)

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
void *thread_function(void *arg);
int main(int argc, char *argv[])
{
    int res;
    pthread_t a_thread;
    void *thread_result;
    //创建线程
    res = pthread_create(&a_thread, NULL, thread_function, NULL);
    if(res != 0)
    {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    sleep(3);
    printf("Cancelling thread...\n");
    //取消子线程
    res = pthread_cancel(a_thread);
    if(res != 0)
    {
        perror("Thread cancelation failed");
        exit(EXIT_FAILURE);
    }
    printf("Waitint for thread to finish...\n");
    //等待子线程结束
    res = pthread_join(a_thread, &thread_result);
    if(res != 0)
    {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    exit(EXIT_SUCCESS);
}

//新线程执行函数
void *thread_function(void *arg)
{
    int i, res, j;
    sleep(1);
    //设置为不可取消
    res = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
    if(res != 0)
    {
        perror("Thread pthread_setcancelstate failed");
        exit(EXIT_FAILURE);
    }
    sleep(3);
    printf("thread cancle type is disable, can‘t cancle this thread\n");
    for(i = 0; i < 3; i++)
    {
        printf("Thread is running (%d)...\n", i);
        sleep(1);
    }
    //设置为可取消
    res = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    if(res != 0)
    {
        perror("Thread pthread_setcancelstate failed");
        exit(EXIT_FAILURE);
    }
    printf("Now change the canclestate is ENABLE\n");
    sleep(200);
    pthread_exit(0);
}

技术分享

 

线程与私有数据

如果需要每个线程有自己私有的全局变量,可以使用同名而不同内存地址的线程私有数据结构,成为私有数据TSD。

int pthread_key_create(pthread_key_t *key, void (*destr_function)(void *)) :创建线程私有数据,地址赋值给key. 所有线程对key可见,但线程可以根据自己的需要,在key中填入不同值,相当于同名不同值。第二个参数表示线程退出时key的资源释放函数。

int pthread_key_delete(pthread_key_t key) :注销一个TSD,不调用destr_sunction?

int pthread_setspecific (pthread_key_t key, const void *pointer) :将pointer的值与key相关联。

void * pthread_getspecific (pthread_key_t key) :读取与key相关联的数据

 

全局变量测试,不使用TSD的情况。

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<stdlib.h>
//全局变量,初值100
int key = 100;
void *helloworld_one(char * argc)
{
    printf("the message is %s\n", argc);
    //修改值为10
    key = 10;
    printf("key=%d, the child id is %u\n", key, pthread_self());
    return 0;
}
void *helloworld_two(char * argc)
{
    printf("the message is %s\n", argc);
    //休眠,让另一个线程先修改值
    sleep(1);
    printf("key=%d, the child id is %u\n", key, pthread_self());
    return 0;
}
int main()
{
    pthread_t thread_id_one;
    pthread_t thread_id_two;
    pthread_create(&thread_id_one, NULL, (void *)*helloworld_one, "helloworld");
    pthread_create(&thread_id_two, NULL, (void *)*helloworld_two, "helloworld");
    pthread_join(thread_id_one, NULL);
    pthread_join(thread_id_two, NULL);
}

两个线程打印的都是修改后的值

技术分享

 

使用TSD,值不同

#include<stdio.h>
#include<pthread.h>
//线程私有数据类型
pthread_key_t key;
void echomsg(void *t)
{
    printf("destructor excuted in thread %u, param=%u\n",pthread_self(),((int *)t));
}
void * child1(void *arg)
{
    int i = 10;
    int tid = pthread_self();
    printf("\nset key value %d in thread %u\n", i, tid);
    //修改私有数据值
    pthread_setspecific(key, &i);
    //等待让另一个线程修改值
    printf("thread one sleep 2 until thread two finish\n");
    sleep(2);
    printf("\nthread %u returns %d, add is %u\n", tid, *((int *)pthread_getspecific(key)),
    (int *)pthread_getspecific(key));
}
void * child2(void *arg)
{
    int temp = 20;
    int tid = pthread_self();
    printf("\nset key value %d in thread %u\n", temp, tid);
    //修改私有数据值
    pthread_setspecific(key, &temp);
    sleep(1);
    printf("\nthread %u returns %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 *)child1, NULL);
    pthread_create(&tid2, NULL, (void *)child2, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_key_delete(key);
    return 0;
    
}

技术分享

【linux高级程序设计】(第十二章)Linux多线程编程

标签:

原文地址:http://www.cnblogs.com/dplearning/p/4689648.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!