嵌入式Memo39 linux高级编程 线程 创建 传参 通信 同步 互斥On Aug 26 2013

线程寄生于进程；

由于进程的地址是私有的因此在进程间上下切换时，系统开销大，从而引入线程。在同一个进程中创建的线程共享该进程的地址空间。

多线程通过第三方线程库来实现。

亲缘线程共享：
            1，可执行的指令；
            2，静态数据；
            3，进程中打开的文件描述符；
            4，信号处理函数；
            5，信号处理函数；
            6，当前工作目录；
            7，用户ID；
            8，用户组ID。

没有同步的线程竞争执行。

线程很容易实现通信（通过全局变量等交换）；

*********************************************
创建线程：主线程和线程竞争执行。

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

int a;

void *fun(void *x)
{
    while(1)
    {
        a = 0;
        sleep(2);
        printf("aaaaaaaaa%daaaaaaaaa\n", a);
    }
}

int main()
{
    pthread_t t;
    pthread_create(&t, NULL, fun, NULL);
    printf("creat_thread : %ld\n", t);
    while(1)
    {
        a = 100;
        sleep(1);
        printf("==========%d==========\n", a);
    }
}

线程传参：
创建了两个线程，都调用同一个函数。根据不同的参数产生不同结果。

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

void *fun(void *a)
{
    while(1)
    {
        sleep(1);
        printf("%s\n", (char *)a);
    }
}

int main()
{

    pthread_t t, t1;
    pthread_create(&t, NULL, fun, "hello");
    printf("creat_thread : %ld\n", t);
    pthread_create(&t1, NULL, fun, "word");
    printf("creat_thread : %ld\n", t1);

    while(1);
}

线程等待函数：
当线程t调用函数fun运行结束才会运行printf。

#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>

void *fun(void *x)
{
    char *buf = malloc(100);
    strcpy(buf, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
    pthread_exit(buf);
}

int main()
{
    pthread_t t;
    pthread_create(&t, NULL, fun, NULL);

    char *p;
    pthread_join(t, (void **)&p);
    printf("%s\n", p);
}

多线程同步：使用信号量函数控制执行顺序。同步即线程按照一定顺序执行。
                  线程同步和互斥靠信号量和互斥锁控制。

#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>

sem_t a;
sem_t b;
sem_t c;
void *fun(void *x)
{
    while(1)
    {
        sem_wait(&a);//申请资源，并值减一；执行wait后的代码
            printf("hello\n");
        sem_post(&b);//释放资源，并值加一
    }
}

void *fun1(void *x)
{
    while(1)
    {
        sem_wait(&c);
            printf("word\n");
        sem_post(&a);
    }
}

void *fun2(void *x)
{
    while(1)
    {
        sem_wait(&b);
            printf("the\n");
        sem_post(&c);
    }
}


int main()
{
    sem_init(&a, 0, 1);
    sem_init(&b, 0, 0);
    sem_init(&c, 0, 0);

    pthread_t t, t1;
    pthread_create(&t, NULL, fun, NULL);
    printf("creat_thread : %ld\n", t);
    pthread_create(&t1, NULL, fun1, NULL);
    printf("creat_thread : %ld\n", t1);
    pthread_create(&t1, NULL, fun2, NULL);
    printf("creat_thread : %ld\n", t1);

    while(1);
}

线程互斥：由于线程间资源共享，同时也有其互斥的场合。
                互斥锁用来保护临界资源的安全。（临界资源，线程双方会用到的资源）；
                线程需先获得互斥锁才能访问临界资源。访问完后释放。
                这里的线程没有同步，竞争执行。lock和unlock中间的资源保护后数据才得以完整。

#include <stdio.h>
#include <pthread.h>
#include <string.h>

pthread_mutex_t mylock;

void *fun_show(void *a)
{
    while(1)
    {
        usleep(10000);
        pthread_mutex_lock(&mylock);
        printf("%s\n", (char *)a);
        pthread_mutex_unlock(&mylock);
    }
}

void *fun_rev(void *a)
{
    int i = 0;
    char *p = (char *)a;
    int len = strlen(p);
    while(1)
    {
        pthread_mutex_lock(&mylock);
        for(i = 0;i<len/2; i++)
        {
            p[i] = p[i]^p[len-i-1];
            p[len-i-1] = p[i]^p[len-i-1];
            p[i] = p[i]^p[len-i-1];
        }
        pthread_mutex_unlock(&mylock);
    }
}

int main()
{
    pthread_mutex_init(&mylock, NULL);
    char buf[] = "123456789";
    pthread_t t;
    pthread_create(&t, NULL, fun_show, buf);
    pthread_create(&t, NULL, fun_rev, buf);
    while(1);
}