线程 介绍

线程与进程区别：
线程是轻量级的进程，本质是进程；
进程是最小分配资源单元，线程是最小的执行单元
进程有独立的地址空间，拥有PCB；线程也有PCB，但没有独立的地址空间(共享内存)

线程基本操作：
获取线程编号：pthread_t pthread_self(void);

线程创建函数：int pthread_create(pthread_t *thread(线程号的类型，不一定是整型), 
const pthread_attr_t *attr(线程属性), void *(*start_routine(启动程序))(void*)(函数指针)， void *arg(参数)

线程退出：void pthread_exit(void *retval)(退出的状态一般为NULL);
线程取消：int pthread_cancel(pthread_t thread);
线程分离：int pthread_detach(pthread_t thread);

阻塞等待线程退出，获取线程退出状态，wait/waitpid：
int pthread_join(pthread_t thread, void **retval);

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

struct pthread
{
	int n;
	char *data;
	char tmp[20];
};

//int count = 0;//全局变量

void *routine1(void *arg)
{
	int *count = (int *)arg;
//	int count = *(int *)arg;
	while(1)
	{
		printf("aaaaa %d\n", (*count)++);
		sleep(1);
	}
}

void *routine2(void *arg)
{
	int i = 1;
	int *count = (int *)arg;
//	int count = *(int *)arg;
	while(1)
	{
		printf("bbbb %d\n", (*count)++);
		sleep(1);
		if(i == 3)
		{
		//	pthread_exit(NULL);
			pthread_cancel(pthread_self());
		}
		i++;
	}
}
int main ()
{
#if 0
	struct pthread hu;
	hu.n = 0;
	(&hu)->data = "abc"//(&hu)->data
	strcpy(	hu.tmp, "bbb");//&(hu.tmp)
#endif
	void*(*arr[2])(void*) = {routine1, routine2};
	int count = 0;
	pthread_t pth[2];
	int i = 0;
	for(i = 0; i < 2; i++)
	{
		int ret = pthread_create(&pth[i], NULL, arr[i], &count);
		if(ret != 0)
		{
			perror("create pthread error\n");
			exit(1);
		}
	}
	for(i = 0; i < 2; i++)
	{
		pthread_join(pth[i], NULL);
	}
	return 0;
}

线程的同步与互斥：
是多个线程中，线程执行工作的顺序，互斥是所有线程无法抢占加锁线程的资源，同步为一个线程等待另一个线程执行完工作后，再执行。
实现同步与互斥的方式：互斥锁，信号量，条件变量。
需要注意：
不要销毁一个已经加锁的互斥量；
静态初始化的互斥量不需要销毁；
已经销毁的互斥量，确保不会再有线程加锁

互斥锁：
销毁：int pthread_mutex_destroy(pthread_mutex_t *mutex);

初始化：int pthread_mutex_init(pthread_mutex_t *restrict mutex,
    const pthread_mutexattr_t *restrict attr);
例：pthread_mutex_t lock;初始化(全局变量)
pthread_mutex_init(&lock, NULL)

静态初始化：pthread_mutex_t = PTHREAD_MUTEX_INITIALIZER;
加锁：int pthread_mutex_lock(pthread_mutex_t *mutex);
试图加锁：int pthread_mutex_trylock(pthread_mutex_t *mutex);
解锁：int pthread_mutex_unlock(pthread_mutex_t *mutex);
带时间现在加锁：int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,
    const struct timespec *restrict abs_timeout);

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *routineA(void *arg)
{
	pthread_mutex_lock(&mutex);
	printf("aaa\n");
	printf("a exit\n");
	pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);

	return NULL;
}

void *routineB(void *arg)
{
	pthread_mutex_lock(&mutex);
	printf("bbb\n");
	printf("b exit\n");
	pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);
	
	return NULL;
}

int main ()
{
	pthread_t ap;
	pthread_t bp;
	int ret = pthread_create(&ap, NULL,routineA, NULL);
	if(ret != 0)
	{
		perror("eroor\n");
		exit(1);

	}
	ret = pthread_create(&bp, NULL, routineB, NULL);
	pthread_join(ap, NULL);
	pthread_join(bp, NULL);

	pthread_mutex_destroy(&mutex);

	return 0;
}

信号量：是一种特殊的变量，访问具有原子性，用于解决进程和线程共享资源引发的同步问题。
用户态进程对sem信号量可以有以下两种操作：
等待信号量：
当信号量为0时，程序等待，当信号量大于0时，信号量减1，程序继续运行.
发送信号量：信号量值加1
通过对信号量的控制，从而实现共享资源的顺序访问
初始化：
int sem_init(sem_t *sem, int pthread, unsigned int value)
//if(sem>0)sem--,并立即返回，否则阻塞。
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
//sem++
int sem_post(sem_t *sem);

获取sem的值：int sem_getvalue(sem_t *sem, int *sval);
销毁sem: int sem_destroy(sem_t *sem);

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
//./a.out  >  a.txt

sem_t empty, full;
pthread_mutex_t mutex;
int arr[6] = {0};
int idx = 0;

void *produce(void *arg)
{
	while(1)
	{
		sem_wait(&empty);
		pthread_mutex_lock(&mutex);
		arr[idx] = rand()%100;
		printf("produce[%d] = %d\n",idx, arr[idx]);
		idx++;
		pthread_mutex_unlock(&mutex);
		sem_post(&full);
		usleep(rand()%1000);

	}
}

void *consume(void *arg)
{
	while(1)
	{
		sem_wait(&full);
		pthread_mutex_lock(&mutex);
		idx--;
		printf("consume[%d] = %d\n",idx, arr[idx]);
		pthread_mutex_unlock(&mutex);
		sem_post(&empty);
		usleep(rand()%1000);

	}
}

int main ()
{
	sem_init(&empty, 0, 6);
	sem_init(&full, 0, 0);
	pthread_mutex_init(&mutex, NULL);
	pthread_t tidA, tidB;
	pthread_create(&tidA, NULL, produce, NULL);
	pthread_create(&tidB, NULL, consume, NULL);
	pthread_join(tidA, NULL);
	pthread_join(tidB, NULL);
	pthread_mutex_destroy(&mutex);
	sem_destroy(&empty);
	sem_destroy(&full);

	return 0;
}

条件变量：
初始化：int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *rest attr);
cond：要初始化的条件变量
attr：NULL
等待(阻塞)：int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
cond：要在这个条件变量上等待
mutex：互斥量

int pthread_cond_signal(pthread_cond_t *cond);//唤醒一个
int pthread_cond_broadcast(pthread_cond_t *cond);//全部唤醒

等待条件：
pthread_mutex_lock(&mutex);
while (条件为假）
    pthread_cond_wait(cond, mutex); 
    //修改条件为真
pthread_mutex_unlock(&mutex);

给条件发送信号：
pthread_mutex_lock(&mutex); 
//设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(&mutex);
在实际执行过程中，往往是执行快的等待执行较慢的。