线程执行流程与其中各个函数的关系

1、线程的创建、终止及控制：

       任何进程在启动时就已有了一个主线程，如果需要再生成线程则使用pthread_create函数，在该函数中可以指定线程的属性、线程例程、传给线程例程的参数。线程例程是一个用户自定义的函数，及线程执行的代码。当线程例程返回时，线程则结束运行，也可以显示调用pthread_exit来退出。线程在创建后可以用pthread_self函数获取线程ID。函数pthread_join使得进程等待线程的终止，调用pthread_join后进程将被挂起，直到指定的某个线程（在pthread_join的参数thread中指定）终止。而pthread_detach函数正好相反，它使得进程不必等待线程的结束，从而允许进程继续执行别的操作，被detach的线程在执行结束后其占用的资源由系统自动收回。

2、线程间的互斥：

       互斥操作 ，就是对某段代码或某个变量修改的时候只能有一个线程在执行这段代码，其他线程不能同时进入这段代码或同时修改变量。pthread常用pthread_mutex互斥体来实现线程互斥操作。pthread_mutex_init函数用于初始化一个互斥体变量。pthread_mutex_lock函数用于给互斥体变量上锁，如果上锁时互斥体已经被被的线程锁住了，那么调用该函数的线程将被阻塞直到互斥体被解锁为止。而pthread_mutex_trylock则是试图锁住互斥体，但在互斥体已经被加锁时不会造成阻塞，而是迅速返回。pthread_mutex_unlock函数对互斥体解锁。pthread_mutex_destroy则用来释放互斥体所占资源。

3、线程的同步：

       同步就是若干个线程等待某个事件的发生，当该事件发生时，一起开始继续执行。在Linux线程中用条件变量来实现同步。函数pthread_cond_init用来创建一个条件变量。pthread_cond_wait和pthread_cond_timewait用来等待条件变量被设置，值得注意的是这两个等待调用需要一个已经上锁的互斥体mutex，这是为了防止在真正进入等待状态之前别的线程有可能设置该条件变量而产生竞争。pthread_cond_broadcast用于设置条件变量，即使事件发生，并使得所有等待该事件的线程不再阻塞。而pthread_cond_signal则是用解除某一个等待线程的阻塞状态。pthread_cond_destroy用来释放一个条件变量的资源。

4、生产者——消费者多线程技术实现：

 

 #include <stdio.h>

 #include <pthread.h>

 #define BUFFER_SIZE 16

 struct prodcons {

       int buffer[BUFFER_SIZE];

       pthread_mutex_t lock;

       int readpos,writepos;

       pthread_cond_t notempty;

       pthread_cond_t notfull;

};

void init (struct prodcons *b) {

       pthread_mutex_init(&b->lock,NULL);

       pthread_cond_init(&b->notempty,NULL);

       pthread_cond_init(&b->notfull,NULL);

       b->readpos=0;

       b->writepos=0;
}

void put(struct prodcons *b, int data) {
{

       pthread_mutex_lock(&b->lock);

       if((b->writepos+1)%BUFFER_SIZE==b->readpos) {

              pthread_cond_wait(&b->notfull,&b->lock);

       }

       b->buffer[b->writepos]=data;

       b->writepos++;

       if(b->writepos>=BUFFER_SIZE)

              b->writepos=0;

       pthread_cond_signal(&b->notempty);

       pthread_mutex_unlock(&b->lock);
}
 
int get(struct prodcons *b)
{
       int data;

       pthread_mutex_lock(&b->lock);

       if(b->writepos==b->readpos) {

              pthread_cond_wait(&b->notempty,&b->lock);
       }
       data=b->buffer[b->readpos];

       b->readpos++;

       if(b->readpos>=BUFFER_SIZE)

              b->readpos=0;

       pthread_cond_signal(&b->notfull);

       pthread_mutex_unlock(&b->lock);

       return data;
} 

#define OVER (-1)

struct prodcons buffer;

void *producer(void *data)
{
       int n;

       for(n=0;n<10000;n++)
       {
              printf(“%d---->\n”,n);

              put(&buffer,n);
       }
       put(&buffer,OVER);

       return NULL;
}

void *consumer(void *data)
{
       int d;

       while(1)
       {
              d=get(&buffer);

              if(d==OVER) 
                     break;

              printf(“---->%d\n”,d);
}
       return NULL;
}

int main(void)
{
       pthread_t th_a,th_b;

       void *retval;

       init(&buffer);

       pthread_create(&th_a,NULL,producer,0);

       pthread_create(&th_b,NULL,consumer,0);

       pthread_join(th_a,&retval);

       pthread_join(th_b,&retval);

       return 0;
}