linux线程及互斥锁

　　进程是资源管理的最小单元，线程是程序执行的最小单元。在操作系统的设计上，从进程演化出线程，最主要的目的就是更好的支持SMP以及减小（进程/线程）上下文切换开销。

　　就像进程有一个PID一样，每个线程也有自己的线程ID，但线程ID只在它所属的环境中有效；

　　　　创建一个新的线程可以通过调用pthread_create()函数来创建；

　　　　函数原型为：

　　　　#include <pthread.h>

　　　　int pthread_create(pthread_t *thread_addr_t, *addr, void *(*start_rtn) (void), void *restrict arg;

　　　　第一个参数是一个指针，它指向一个pthread_t类型的结构，再创建一个线程时，这个指针指向的变量里会写入

　　　　新线程的ID，第二个参数对线程的属性进行设置；一般默认为NULL；

　　　　最后两个参数分别是线程将要启动执行的函数以及将要传递给这个函数的参数。

　　　　下面的代码是创建一个新的线程：　　

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

/*新线程要执行的函数*/
void *hello(void *arg)
{
    printf("hello world
");
}

int main()
{
    pthread_t pid = 0;
    int ret = 0;

    /*获得一个新的线程*/    
    ret = pthread_create(&pid, NULL, hello, NULL);
    if(ret < 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }
    
    /* 检查线程退出状态*/
    pthread_join(pid, NULL);
    exit(EXIT_SUCCESS);        
}

　　　　二：互斥锁

　　　　　　下面代码是主线程和工作线程共享用户的输入缓冲，主线程创建了工作线程用于统计用户输入的字符数，它们之间通过互斥锁保证对输入缓冲的访问不发生冲突；

　　

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#define WORK_SIZE 1024
pthread_mutex_t work_mutex;
char work[1024]; /* 工作区*/
int time_to_exit = 0; /*退出标志*/

void *thread_function(void *arg);


int main()
{
    int ret = 0;
    pthread_t tid  = 0;
    void *thread_result;

    /* 对互斥锁进行初始化*/
    ret = pthread_mutex_init(&work_mutex, NULL);
    if(ret != 0) {
        perror("mutex init failure");
        return 1;
    }

    ret = pthread_create(&tid, NULL, thread_function, NULL);
    if(ret != 0) {
        perror("pthread_create");
        return 1;
    }

    /*给工作区加上锁，把文本读到里面
      然后给它解锁允许被其他线程访问*/
    pthread_mutex_lock(&work_mutex);
    printf("Inpu some txt, Enter 'end' to finish
");
    while(!time_to_exit) {
        fgets(work, 1024, stdin);
        pthread_mutex_unlock(&work_mutex);

        while(1) {
            pthread_mutex_lock(&work_mutex);
            if(work[0] != '') {
                pthread_mutex_unlock(&work_mutex);
                sleep(1);
                
            }
            else
                break;
        }    
    }
    pthread_mutex_unlock(&work_mutex);
    ret = pthread_join(tid, &thread_result);
    if(ret != 0) {
        perror("pthread_join");
        return 1;
    }
    
    pthread_mutex_destroy(&work_mutex);        
}

void *thread_function(void *arg)
{
    sleep(1);
    /*新线程试图对互斥量进行加锁*/
    pthread_mutex_lock(&work_mutex);
    while(strncmp("end", work, 3) != 0 ) {
        printf("you input %d characters
", strlen(work) - 1);
        /*把第一个字符设置为空字符已经完成了字符统计工作*/
        work[0] = '';
        pthread_mutex_unlock(&work_mutex);
        sleep(1);
        
        /*周期性的尝试给互斥量加锁，如果加锁成功，
         就检查主线程是否有新字符需要统计，如果没有，
        解开互斥量继续等待*/            
        pthread_mutex_lock(&work_mutex);
        while(work[0] == '') {
            pthread_mutex_unlock(&work_mutex);
            sleep(1);
            pthread_mutex_lock(&work_mutex);    
        }
    }
    /*设置退出标志*/
    time_to_exit = 1;
    work[0] = '';
    pthread_mutex_unlock(&work_mutex);
    pthread_exit(0);
}