Linux多线程编程

1）线程的基本操作

1.pthread_create()

#include <pthread.h> 

int pthread_create(pthread_t * tidp，const  pthread_attr_t * attr，void*(*start_rtn)(void)，void*arg)

创建线程成功后返回值为0

tidp：线程id，create会创建线程，并自动将线程id返回给tidp

attr：线程属性，通常为NULL

start_rtn：线程要执行的函数，通常参数为void时，arg为NULL，参数为void *时，arg为void*类型

arg：start_rtn的参数

如果进程中任何一个线程中调用exit或_exit，那么整个进程都会终止。

线程的正常退出方式有：

(1) 线程从启动例程中返回

(2) 线程可以被另一个进程终止

(3) 线程自己调用pthread_exit函数

2.pthread_exit()

#include <pthread.h>

void pthread_exit(void * rval_ptr)

功能：终止调用线程

Rval_ptr:线程退出返回值的指针

3.pthread_join()

#include <pthread.h>

int pthread_join(pthread_t tid,void **rval_ptr)

功能：阻塞调用线程，直到指定的线程终止。

Tid :等待退出的线程id

Rval_ptr：线程退出的返回值的指针

实例：

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

char message[]="hello world!";

void * thread_function(void *arg)
{
    printf("thread function is running, argument is %s\n",(char *)arg);//此时arg的值==message

    sleep(3);

    strcpy(message,"how are you");//修改全局变量的值

    pthread_exit("thank you for your CPU time! \n"); //pthread_exit函数的参数会返回给pthread_join函数
}

int main()
{
    pthread_t a_thread;     //创建线程

    void * thread_result;

    int ret;

    ret = pthread_create(&a_thread,NULL,(void *)thread_function,(void *)message);//创建线程后，直接执行函数thread_function,message是传给函数thread_function的参数值

    if(ret != 0)  //返回值不是0，则创建失败
    {
        perror("create thread error");

        exit(0);
    }

    printf("waiting for thread to finish...\n");

    ret = pthread_join(a_thread,&thread_result);//join函数接受线程号为a_thread的返回值，返回值存在thread_result中，这是二级指针。

    if(ret != 0)
    {
        perror("thread join error");

        exit(0);
    }

    printf("thread joined,it returned %s\n",(char*)thread_result);

     printf("message is now %s\n",message);

    return 0;
}                                                 

编译时后面要加-lpthread 

4.pthread_self()

获取线程id

#include <stdio.h>
#include <pthread.h>
#include <unistd.h> /*getpid()*/

void *create(void *arg)
{
    printf("New thread .... \n");
    
    printf("This thread's id is %u  \n", (unsigned int)pthread_self());//线程id
	 
    printf("The process pid is %d  \n",getpid());//进程id 
    return (void *)0;
} 

int main(int argc,char *argv[])
{
    pthread_t tid;
    int error;

    printf("Main thread is starting ... \n");

    error = pthread_create(&tid, NULL, create, NULL);
    
    printf("the tid=%d\n",tid);          //线程id 

    if(error)
    {
        printf("thread is not created ... \n");
        
        return -1;
    }
    printf("The main process's pid is %d  \n",getpid());//进程id 
    
    sleep(1);
    
    return 0;
}

2）线程同步

进行多线程编程，因为无法知道哪个线程会在哪个时候对共享资源进行操作，因此让如何保护共享资源变得复杂，通过下面这些技术的使用，可以解决。

 线程之间对资源的竞争：

1 .互斥量Mutex                

2 .号灯Semaphore                

3 .条件变量Conditions

1.互斥量（锁）

1.先定义互斥锁：

pthread_mutex_t mutex;


2.在使用前，先进行初始化，两者选其一：

静态初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

动态初始化：int  pthread_mutex_init( pthread_mutex_t  *   mutex ,  const 

pthread_mutexattr_t  *  attr); 

动态初始化中：pthread_mutex_init(锁的指针，锁的属性)。  

例如：pthread_mutex_init(&mutex,NULL); 


锁的属性其他选项：

* PTHREAD_MUTEX_TIMED_NP，即NULL，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个

等待队列，并在解锁后按优先级获得锁。

* PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock

解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。

* PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与

PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。

* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。



3.加锁
int pthread_mutex_lock(pthread_mutex_t *mutex)  

资源被占用会阻塞



int pthread_mutex_trylock(pthread_mutex_t *mutex)  

trylock是非阻塞调用模式, 如果互斥量没被锁住, trylock函数将对互斥量加锁, 并获得对共享资源的访问

权限; 如果互斥量被锁住了,trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态


4.解锁

int pthread_mutex_unlock(pthread_mutex_t *mutex)



5.删除锁
 int pthread_mutex_destroy(pthread_mutex_t *mutex)

实例：

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

int ticket = 10;//十张票

pthread_mutex_t mutex;


void *sell_ticket1(void)
{
    while(1)
	{
        ret = pthread_mutex_trylock(&mutex); 
		if(ticket > 0)
		{
      
		    sleep(1);
			printf("sell ticket--> chool ticket:%d\n",--ticket);
            
		    pthread_mutex_unlock(&mutex);
		
		}
		else
		{
		     
		    pthread_mutex_unlock(&mutex);
			break;
		}

		pthread_mutex_unlock(&mutex);
	}

	return NULL;
}

void *sell_ticket2(void)
{
    int ret;

	while(1)
	{
        ret = pthread_mutex_trylock(&mutex);
		if(ret != EBUSY)
		{
		    if(ticket > 0)
		    {
            
		      sleep(1);
			  printf("sell ticket--> chool ticket:%d\n",--ticket);
            
		      pthread_mutex_unlock(&mutex);
			
		    }
		    else
		    {
		     
		        pthread_mutex_unlock(&mutex);
			    break;
		    }

		    pthread_mutex_unlock(&mutex);
		}
	}
}

void *sell_ticket3(void)
{
    int ret;

	while(1)
	{
        ret = pthread_mutex_trylock(&mutex);
		if(ret != EBUSY)
		{
		    if(ticket > 0)
		    {
           
		      sleep(1);
			  printf("sell ticket--> chool ticket:%d\n",--ticket);
            
		      pthread_mutex_unlock(&mutex);
			
		    }
		    else
		    {
		     
		        pthread_mutex_unlock(&mutex);
			    break;
		    }

		    pthread_mutex_unlock(&mutex);
		}
	}

	return NULL;
}

int main()
{
    int i=0, ret=0;
    pthread_t id1,id2,id3;
    
 

    pthread_mutex_init(&mutex,NULL); //初始化为默认锁 

    ret = pthread_create(&id1, NULL, (void*)sell_ticket1, NULL);
    ret = pthread_create(&id2, NULL, (void*)sell_ticket1, NULL);
    ret = pthread_create(&id3, NULL, (void*)sell_ticket1, NULL);
    

    
    pthread_join(id1, NULL);
	printf("id1 exit!\n");
    pthread_join(id2, NULL);
	printf("id2 exit!\n");
    pthread_join(id3, NULL);
	printf("id3 exit!\n");

	printf("hello world!\n");
    
    return 0;
}

2.信号量

3.条件变量

1.创建条件变量

pthread_cond_t  cond; 



2.条件变量初始化：二者取其一

静态初始化：pthread_cond_t  cond = PTHREAD_COND_INITIALIZER

动态初始化： int pthread_cond_init(pthread_cond_t * cond，pthread_condattr_t * cond_attr);

动态初始化中：int pthread_cond_init（条件变量的指针，条件变量的属性）

返回0表示成功，其他都表示失败

例如：pthread_cond_init(cond，NULL)



3.条件变量等待

int pthread_cond_wait( pthread_cond_t * cond,pthread_mutex_t *mutex);

(条件变量指针，锁指针)

作用：当满足条件时，一般与if连用，阻塞自己并且解锁，当被signal或者broadcast发送的信号和条件变量

cond一样时，函数被唤醒，解除阻塞，并且要重新申请获取锁


int pthread_cond_timedwait(pthread_cond_t * cond,pthread_mutex_t *mutex, const struct 

timespec *sbstime)

作用：与上面一样，当在第三个参数规定的时间没有醒来时，该函数会自动醒来并且重新申请获取锁




4.发送信号唤醒 

int pthread_cond_signal(pthread_cond_t * cond)

(条件变量指针)

至少唤醒一个阻塞在满足条件变量的线程


int pthread_cond_brocast(pthread_cond_t * cond)

以广播方式唤醒所有满足条件变量的线程



5.条件变量的销毁：
int pthread_cond_destroy(pthread_cond_t *cv); 返回0表示成功，返回其他值都表示失败。

实例：商人与购买例子

#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);//阻塞并等待队列非满（notfull）的信号 ，该信号由get()函数里，消费者购买商品后会发送一个队列notfull的信号 
    }
    
    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);//阻塞并等待队列非空（notempty）的信号，该信号由put()函数里，商人向货架上放商品后，会放送一个队列非空（notempty）的信号 
    }

    data = b->buffer[b->readpos];//买商品操作 
    b->readpos++;
    if(b->readpos >= BUFFER_SIZE)
    {
        b->readpos = 0;
    }
    pthread_cond_signal(&b->notfull);//发送队列非满（notfull）的信号 
    pthread_mutex_unlock(&b->lock);
    return data;
}

#define OVER -1

struct prodcons buffer;

 void * producer(void *data)      //商人放商品 
{
    int n;
    for(n = 0;n < 20;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()
{
    pthread_t th_a,th_b;   //创建两个线程 
    void *retval;
    
    init(&buffer);     //初始化锁，条件变量，队列的头尾 

    pthread_create(&th_a,NULL,producer,0);   //此线程执行商人放商品操作，调用producer函数 
    pthread_create(&th_b,NULL,consumer,0);   //此线程执行人购买商品操作，调用consumer函数 

    pthread_join(th_a,&retval); //获取线程的返回值 
    pthread_join(th_b,&retval);

    return 0;
}