linux基本概念(四)----线程编程

先给自己打个广告，本人的微信公众号正式上线了，搜索:张笑生的地盘，主要关注嵌入式软件开发，足球等等，希望大家多多关注，有问题可以直接留言给我，一定尽心尽力回答大家的问题

一 why

在本系列的第一篇博文《linux基本概念(一)----进程和线程》中，我们谈到了线程，它是如何诞生，和进程之间的区别，以及什么时候需要线程的。
在我们很多实际项目中，完成某一项工作并不需要多进程的方式，因为进程会消耗更多的系统资源，同时不同进程之间数据通信也需要特殊的方式处理，我们采取线程即可避免进程的这两个缺点，基于此本篇来谈谈如何实现线程编程。

二 what

实际上线程和进程是紧密联系，密不可分的，linux为每个进程和线程都是创建了一个task_struct的结构体，它是相当复杂的结构体，这里就不贴出来了。
实际上linux并区分进程和线程，都认为是一个task任务，进程和线程的关系如下图所示，当一个进程中只有一个线程时，这个线程就独占进程的整个空间，这个时候线程和进程的差别就不是很大了

那么linux是如何管理线程的呢？
Linux使用pthread线程库来管理线程，因此编译的时候需要指定链接选项“-lpthread”，这是一个第三方库，其中“p”表示这个线程库遵循POSIX规范。
（1）线程创建

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                          void *(*start_routine) (void *), void *arg);

（2）线程回收

int pthread_join(pthread_t thread, void **retval);
	参数1： 要回收的线程，如果这个线程没有结束，会阻塞

（3）线程结束

void pthread_exit(void *retval);
	retval可以被其他线程通过pthread_join获取到
	retval不能指向线程中栈中的局部变量

（4）线程间同步
为什么需要线程间同步？
在同一个进程中，不同线程之间是共享资源的，也就是说不同线程可以访问属于这个进程中的一切全局变量。但是由于线程之间的执行次序是未知的，有可能某一个线程正在读一个全局变量，但是此时由于另外一个高优先级的线程到来，正在执行写这个全局变量，这样的操作是需要严格避免的。因此多个线程访问共享数据时需要同步或者互斥机制。
a. 信号量

信号量  P操作 V操作
Posix 信号量
1. 无名信号量
	基于内存的信号量，用于线程之间的同步
2. 有名信号量
	既可以用于线程之间，也可以用于进程之间

相关函数

1. 初始化 sem_init
	int sem_init(sem_t *sem, int pshared, unsigned int value);
	sem: 指向要初始化的信号量
	pshared: 0---线程间    1---进程间
	value： sem的初始值
2. P操作 : sem_wait
	int sem_wait(sem_t *sem);
3. V操作 : sem_post
	int sem_post(sem_t *sem);

b. 互斥锁

临界资源 
	是一种共享资源，可以被多个线程/进程访问
	一次只允许一个任务(线程/进程)访问
临界区
	访问临界区的代码

互斥机制
	mutex互斥锁
	任务再访问临界资源前申请锁，访问完之后释放锁

相关函数

1. 互斥锁初始化
	pthread_mutex_init
2. 申请锁
	pthread_mutex_lock
	如果无法获得锁，任务阻塞
3. 释放锁
	pthread_mutex_unlock

三 how

（1）创建一个线程示例

#include "stdio.h"
#include "stdlib.h"
#include <unistd.h>
#include <pthread.h>

unsigned int pthread_inter = 0;

void *fun(void *var)
{
    int j;
    
    while(!pthread_inter);
    for (j = 0; j < 10; j++) {
        usleep(100);
        printf("this is fun j=%d\n", j);
    }
}

int main()
{
    int i, ret;
    char str[] = "hello linux\n";
    pthread_t tid;
    
    ret = pthread_create(&tid, NULL, fun, (void *)str);
    if (ret < 0) {
        printf("create thread fail\n");
        return -1;
    }
    
    for (i = 0; i < 10; i++) {
        usleep(100);
        printf("this is main i=%d\n", i);
    }
    pthread_inter = 1;

    while(1);
    return 0;
}

（2）线程同步之信号量

#include "stdio.h"
#include "stdlib.h"
#include <unistd.h>
#include <pthread.h>
#include "string.h"
#include <semaphore.h>

char buf[32];
sem_t sem_write;
sem_t sem_read;

void *fun_write(void *var)
{
	while (1) {
		sem_wait(&sem_read);
		printf("you enter %lu char %s\n", strlen(buf), buf);
		sem_post(&sem_write);
	}
}

int main()
{
    	int ret;
   	pthread_t tid;

    	if (sem_init(&sem_write, 0, 1) < 0){
       	 perror("sem_init");
        	exit(-1);
    	}

    	if (sem_init(&sem_read, 0, 0) < 0){
       	 perror("sem_init");
        	exit(-1);
    	}

    	ret = pthread_create(&tid, NULL, fun_write, NULL);
    	if (ret < 0) {
        	printf("create thread fail\n");
        	exit(-1);
    	}

	memset(buf, 0, sizeof(buf));
	do {
		sem_wait(&sem_write);
		fgets(buf, 32, stdin);
		sem_post(&sem_read);
   	} while(strncmp(buf, "quit", 4) != 0);

	return 0;

}

（3）线程互斥之互斥锁

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

pthread_mutex_t lock;
unsigned int count, value1, value2;

void *fun_write(void *var)
{
	while (1) {
		#ifdef __LOCK__	
			pthread_mutex_lock(&lock);
		#endif
		if (value1 != value2) {
			printf("value1=%d value2=%d\n", value1, value2);
			usleep(100000);
		}
		#ifdef __LOCK__
			pthread_mutex_unlock(&lock);
		#endif
	}

//	return NULL;
}

int main()
{
    	int ret;
   	pthread_t tid;

    	if (pthread_mutex_init(&lock, NULL) < 0){
       	 	perror("phtread_mutex_init");
        	exit(-1);
    	}

    	ret = pthread_create(&tid, NULL, fun_write, NULL);
    	if (ret < 0) {
        	printf("create thread fail\n");
        	exit(-1);
    	}

	while (1) {
		count++;
		#ifdef __LOCK__
			pthread_mutex_lock(&lock);
		#endif
		value1 = count;
		value2 = count;
		#ifdef __LOCK__
			pthread_mutex_unlock(&lock);
		#endif
	}

	return 0;

}

四 Test

（1）上面的第一个和第二个示例程序就不编译运行了，留给读者自己实验
（2）我们来看一下第三个示例程序
我们先看指定了宏定义时的运行情况

1. 编译：gcc thread_lock.c -o thread_lock -lpthread -D__LOCK__  //-D表示指定编译选项，相当于在程序中有一个宏定义 #define __LOCK__
2. 运行 ./thread_lock   发现并没有任何输出

我们再来看一看不指定编译选项“-D__LOCK__”

1. 编译：gcc thread_lock.c -o thread_lock -lpthread
2. 运行 ./thread_lock   发现此时在console上有输出打印

请大家自己思考一下，为什么会出现如下的打印信息？