1.线程简介
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。
2.线程通讯--读写锁
2.1 读写锁简介
读写锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。
一次只有一个线程可以占有写模式的读写锁，但是可以有多个线程同时占有读模式的读写锁。正是因为这个特性，当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。
当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权， 但是如果线程希望以写模式对此锁进行加锁，它必须直到所有的线程释放锁。
通常，当读写锁处于读模式锁住状态时，如果有另外线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求，这样可以避免读模式锁长期占用，而等待的写模式锁请求长期阻塞。
读写锁适合于对数据结构的读次数比写次数多得多的情况。因为，读模式锁定时可以共享， 以写模式锁住时意味着独占， 所以读写锁又叫共享-独占锁。
2.2 相关函数
#include <pthread.h>
//销毁读写锁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
//读写锁初始化
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);
//读加锁
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
//写加锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
//解锁
pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
2.3 示例
创建两个线程，2个子线程读数据，主线程负责写数据。
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int data=0;
pthread_rwlock_t rwlock;
/*读线程1*/
void *pth1_work(void *arg)
{
int a;
while(1)
{
pthread_rwlock_rdlock(&rwlock);//读上锁
a=data;
printf("----------------线程1读数据-----------------------\n");
sleep(5);
printf("[%s]线程1,data=%d\n",__FUNCTION__,a);
pthread_rwlock_unlock(&rwlock);//解锁
usleep(10);
}
}
/*读线程2*/
void *pth2_work(void *arg)
{
int a;
while(1)
{
pthread_rwlock_rdlock(&rwlock);//读上锁
a=data;
printf("----------------线程2读数据-----------------------\n");
sleep(5);
printf("[%s]线程1,data=%d\n",__FUNCTION__,a);
pthread_rwlock_unlock(&rwlock);//解锁
usleep(10);
}
}
int main()
{
pthread_rwlock_init(&rwlock,NULL);/*创建读写锁*/
/*创建线程1*/
pthread_t id;
pthread_create(&id,NULL,pth1_work,NULL);
pthread_detach(id);//设置为分离属性
/*创建线程2*/
pthread_create(&id,NULL,pth2_work,NULL);
pthread_detach(id);//设置为分离属性
/*写线程*/
while(1)
{
pthread_rwlock_wrlock(&rwlock);//写加锁
printf("主线程写数据............\n");
sleep(3);
data+=100;
printf("主线程写数据完\n");
pthread_rwlock_unlock(&rwlock);//解锁
usleep(10);
}
}
3.线程通讯--条件变量
3.1 条件变量简介
条件变量是线程可用的一种同步机制，条件变量给多个线程提供了一个回合的场所，条件变量和互斥量一起使用，允许线程以无竞争的方式等待特定的条件发生。
条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。
注意：条件变量需要和互斥锁一起使用。
例如：线程4推送屏幕图像数据给各个子线程，需要1s推送一次；线程1、2、3获取推送的数据的频率则远小于1s时间，若此类情况使用读写锁则会导致子线程频繁获取相同数据帧，极大浪费CPU资源。而使用条件变量则可以有效解决资源浪费问题。
3.2 相关函数
#include <pthread.h>
//销毁条件变量
int pthread_cond_destroy(pthread_cond_t *cond);
//动态初始化条件变量
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
//静态初始化条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
//等待条件变量产生
pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
//广播唤醒所有线程
int pthread_cond_broadcast(pthread_cond_t *cond);
//随机唤醒一个线程
int pthread_cond_signal(pthread_cond_t *cond);
3.3 示例
创建5个子线程，子线程等待条件变量产生，主线程捕获 SIGINT(CTRL+C信号)和SIGQUIT(CTRL+\)信号，通过信号实现广播唤醒所有线程和随机唤醒一个线程。
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <signal.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//互斥锁
pthread_cond_t cond;
void *pth_work(void *arg)
{
int cnt=(int *)arg;
pthread_mutex_lock(&mutex);//互斥锁上锁
printf("线程%d运行中.....\n",cnt);
pthread_cond_wait(&cond,&mutex);//等待条变量产生,本身自带解锁功能
printf("线程%d唤醒成功,id=%lu\n",cnt,pthread_self());
pthread_mutex_unlock(&mutex);//互斥锁解锁
}
void sig_work(int sig)
{
if(sig==SIGINT)
{
pthread_mutex_lock(&mutex);//互斥锁上锁
pthread_cond_signal (&cond);//随机唤醒一个线程
pthread_mutex_unlock(&mutex);//互斥锁解锁
}
if(sig==SIGQUIT)
{
pthread_mutex_lock(&mutex);//互斥锁上锁
pthread_cond_broadcast(&cond);//广播唤醒所有线程
pthread_mutex_unlock(&mutex);//互斥锁解锁
}
}
int main()
{
signal(SIGINT,sig_work);//捕获CTRL+C
signal(SIGQUIT,sig_work);//捕获CTRL+\
/*创建条件变量*/
pthread_cond_init(&cond,NULL);
pthread_t pth[5];
int i=0;
for(i=0;i<5;i++)
{
pthread_create(&pth[i],NULL,pth_work,(void*)i);
}
for(i=0;i<5;i++)
{
pthread_join(pth[i],NULL);
}
pthread_cond_destroy(&cond);
pthread_mutex_destroy(&mutex);
printf("所有线程结束\n");
return 0;
}
3.4 示例2
编写程序完成如下功能：
1）有一int型全局变量g_Flag初始值为0；
2） 在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1
3） 在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2
4） 主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <signal.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//互斥锁
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int g_Flag=0;
void *pth_work(void *arg)
{
printf("this is thread1\n");
pthread_mutex_lock(&mutex);
if(g_Flag==2)
{
g_Flag=1;
pthread_cond_signal(&cond);//随机唤醒一个线程
}
else
{
g_Flag=1;
}
printf("线程1:%d\n",g_Flag);
pthread_mutex_unlock(&mutex);
}
void *pth2_work(void *arg)
{
printf("this is thread2\n");
pthread_mutex_lock(&mutex);
if(g_Flag==1)
{
g_Flag=2;;
pthread_cond_signal(&cond);//随机唤醒一个线程
}
else
{
g_Flag=2;
}
printf("线程2:%d\n",g_Flag);
pthread_mutex_unlock(&mutex);
}
int main()
{
pthread_t pth;
/*创建线程1*/
pthread_create(&pth,NULL,pth_work,NULL);
pthread_detach(pth);//设置为分离属性
/*创建线程2*/
pthread_create(&pth,NULL,pth2_work,NULL);
pthread_detach(pth);//设置为分离属性
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond,&mutex);
pthread_mutex_unlock(&mutex);
pthread_cond_destroy(&cond);
pthread_mutex_destroy(&mutex);
printf("所有线程结束\n");
return 0;
}
