1.再论进程
使用进程的优势：
(1).每个进程互相独立，不影响主程序的稳定性，子进程崩溃没关系；
使用进程的劣势：
(1).进程间切换开销大，效率低一些；
(2).进程间通信麻烦且效率低，适合小数据量传送；
解决方案就是线程技术：
线程的优点：
(1).进程间切换开销大；
(2).线程没有单独的地址空间，它们共享大部分数据，一个线程死掉就相当于整个进程死掉。
(3).多线程在多核心CPU架构下上面更有优势。
线程的缺点：
(1).线程没有独立的地址空间，它们共享大部分数据，一个线程死掉就相当于整个进程死掉；
2.线程常见函数
1.线程创建与回收
(1)pthread_create 主线程用来创造子线程的
(2)pthread_join 主线程用来等待（阻塞）回收子线程，等这个子线程终止的时候主线程去回收它
(3)pthread_detach 主线程用来分离子线程，分离后主线程不必再去回收子线程，子线程终止的时候自己回收自己
下面这两个一般是二选一使用，不能同时选 也不能都不选，
2.线程取消
(1)pthread_cancel 一般都是主线程调用该函数去终止指定子线程
(2)pthread_setcancelstate 子线程设置自己是否允许被终止
(3)pthread_setcanceltype
3.线程函数退出相关
(1)pthread_exit与return退出
(2)pthread_cleanup_push
(3)pthread_cleanup_pop
4.获取线程id
(1)pthread_self
3.线程同步之信号量
函数原型 ：int sem_init(sem_t *sem, int pshared, unsigned int value);
参数解释 ：
sem ：指向信号量对象
pshared : 指明信号量的类型。当为0时，用于进程；当为0时，用于线程。
value : 指定信号量值的大小
返回值：成功返回0，失败时返回-1，并设置errno。
作用：创建信号量，并为信号量值赋初值。
函数原型：int sem_post(sem_t *sem);
参数解释 ：
sem ：指向信号量对象
返回值：成功返回0，失败时返回-1，并设置errno。
作用: 以原子操作的方式为将信号量增加1
函数原型：sem_wait(sem_t *sem);
参数解释 ：
sem ：指向信号量对象
返回值：成功返回0，失败时返回-1，并设置errno
作用: 以阻塞的方式等待信号量，当信号量的值大于零时，执行该函数信号量减一，当信号量为零时，调用该函数的线程将会阻塞。
函数原型：sem_destroy(sem_t *sem);
参数解释 ：
sem ：指向信号量对象
返回值：成功返回0，失败时返回-1，并设置errno
作用: 清理信号量占有的资源，当调用该函数，而有线程等待此信号量时，将会返回错信息。
使用多线程实现：用户从终端输入任意字符然后统计个数显示，输入end则结束
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
char buf[200] = {0};
sem_t sem;
unsigned int flag = 0;
// 子线程程序，作用是统计buf中的字符个数并打印
void *func(void *arg)
{
// 子线程首先应该有个循环
// 循环中阻塞在等待主线程激活的时候，子线程被激活后就去获取buf中的字符长度，然后打印；完成后再次被阻塞
sem_wait(&sem);
//while (strncmp(buf, "end", 3) != 0)
while (flag == 0)
{
printf("本次输入了%d个字符\n", strlen(buf));
memset(buf, 0, sizeof(buf));
sem_wait(&sem);
}
pthread_exit(NULL);
}
int main(void)
{
int ret = -1;
pthread_t th = -1;
sem_init(&sem, 0, 0);//创建信号量并赋初值为0
ret = pthread_create(&th, NULL, func, NULL);
if (ret != 0)
{
printf("pthread_create error.\n");
exit(-1);
}
printf("输入一个字符串，以回车结束\n");
while (scanf("%s", buf))
{
if (!strncmp(buf, "end", 3)) // 去比较用户输入的是不是end，如果是则退出，如果不是则继续
{
printf("程序结束\n");
flag = 1;
sem_post(&sem);
//exit(0);
break;
}
// 主线程在收到用户收入的字符串，并且确认不是end后，就去发信号激活子线程来计数。
// 子线程被阻塞，主线程可以激活，这就是线程的同步问题。信号量就可以用来实现这个线程同步
sem_post(&sem);
}
// 回收子线程
ret = pthread_join(th, NULL);
if (ret != 0)
{
printf("pthread_join error.\n");
exit(-1);
}
printf("子线程回收成功\n");
sem_destroy(&sem);
return 0;
}打印结果:
4.线程同步之互斥锁
(1)互斥锁又叫互斥量（mutex）
(2)相关函数： pthread_mutex_init 创建锁 pthread_mutex_destroy 销毁锁
pthread_mutex_lock 加锁 pthread_mutex_unlock 解锁
互斥锁和信号量的关系：可以认为互斥锁是一种特殊的信号量
互斥锁主要用来实现关键段保护，防止多线程对同一个数据进行操作 。
用互斥锁来实现上面的代码：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
char buf[200] = {0};
pthread_mutex_t mutex;
unsigned int flag = 0;
void *func(void *arg)
{
sleep(1);
while (flag == 0)
{
pthread_mutex_lock(&mutex);
printf("本次输入了%ld个字符\n", strlen(buf));
memset(buf, 0, sizeof(buf));
pthread_mutex_unlock(&mutex);
sleep(1);
}
pthread_exit(NULL);
}
int main(void)
{
int ret = -1;
pthread_t th = -1;
pthread_mutex_init(&mutex, NULL);
ret = pthread_create(&th, NULL, func, NULL);
if (ret != 0)
{
printf("pthread_create error.\n");
exit(-1);
}
printf("输入一个字符串，以回车结束\n");
while (1)
{
pthread_mutex_lock(&mutex);
scanf("%s", buf);
pthread_mutex_unlock(&mutex);
if (!strncmp(buf, "end", 3)) // 去比较用户输入的是不是end，如果是则退出，如果不是则继续
{
printf("程序结束\n");
flag = 1;
break;
}
sleep(1);
}
// 回收子线程
ret = pthread_join(th, NULL);
if (ret != 0)
{
printf("pthread_join error.\n");
exit(-1);
}
printf("子线程回收成功\n");
pthread_mutex_destroy(&mutex);
return 0;
}编译运行：
5.线程同步之条件变量
什么是条件变量
我们定义了一个条件，当一个线程不满足这个条件的时候，它会阻塞等待这个条件发生。而当另一线程让这个条件满足的时候，会发送一个信号，就激活阻塞的那个线程让他运行。
条件变量是线程中特有的。
相关函数
pthread_cond_init pthread_cond_destroy
pthread_cond_wait pthread_cond_signal/pthread_cond_broadcast
使用条件变量实现上面代码：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
char buf[200] = {0};
pthread_mutex_t mutex;
pthread_cond_t cond;
unsigned int flag = 0;
void *func(void *arg)
{
//sleep(1);
while (flag == 0)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("本次输入了%d个字符\n", strlen(buf));
memset(buf, 0, sizeof(buf));
pthread_mutex_unlock(&mutex);
//sleep(1);
}
pthread_exit(NULL);
}
int main(void)
{
int ret = -1;
pthread_t th = -1;
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
ret = pthread_create(&th, NULL, func, NULL);
if (ret != 0)
{
printf("pthread_create error.\n");
exit(-1);
}
printf("输入一个字符串，以回车结束\n");
while (1)
{
//pthread_mutex_lock(&mutex);
scanf("%s", buf);
pthread_cond_signal(&cond);
//pthread_mutex_unlock(&mutex);
if (!strncmp(buf, "end", 3)) // 去比较用户输入的是不是end，如果是则退出，如果不是则继续
{
printf("程序结束\n");
flag = 1;
//exit(0);
break;
}
//sleep(1);
}
// 回收子线程
ret = pthread_join(th, NULL);
if (ret != 0)
{
printf("pthread_join error.\n");
exit(-1);
}
printf("子线程回收成功\n");
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}子线程中的 加锁 解锁 函数并不是多余的，因为条件变量等待函数里有mutex参数，所以要使用条件变量，必须要有互斥锁的参与，加锁 解锁 函数必须写到等待函数的前后。
816
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
