多线程编程学习（一）——共享数据同步&线程锁
多线程共享变量会涉及到数据的安全问题。
验证测试程序如下，两个线程共同对一个（非全局）变量操作，根据初始打印可知地址一样，非全局。
#include <stdio.h>
#include <pthread.h>
static pthread_t thread_a_id;
static pthread_t thread_b_id;
void *printA(void *pA)
{
printf("%p!\n",pA);
int *p = pA;
while(1)
{
*p = 2;
if(5 == *p)
{
printf("=============\n");
}
}
return NULL;
}
void *changeA(void *pA)
{
printf("%p!\n",pA);
int *p = pA;
while(1){
*p = 5;
}
return NULL;
}
int main()
{
int a;
a = 1;
int iRet = 0;
iRet = pthread_create(&thread_a_id,NULL,printA,&a);
if(iRet != 0)
{
printf("create failed!\n");
}
iRet = pthread_create(&thread_b_id,NULL,changeA,&a);
if(iRet != 0)
{
printf("create failed!\n");
}
while(1)
{
sleep(5);
}
}
因为while(1)运转过快，难以人工分辨，所以设置遇到变量值不符合预期时打印即可。
运行结果：
============= ============= ============= ============= ============= =============
证明线程间数据被互相篡改，不安全。
线程b就不打印了，肯定也会遇到a被改成2的情况。（为了演示更全面，下边的例子会把a和b线程改对等）
解决思路
我目前所用的，通常是数据加锁和变量不共享两种思路，但是数据不共享很局限，不能满足很多需求，比如多线程需要共同维护一个用户哈希表。
所以就需要给数据加锁。
手动加（实际上简陋、不可用的烂）锁：
#include <stdio.h>
#include <pthread.h>
static pthread_t thread_a_id;
static pthread_t thread_b_id;
static int i = 0;
void *printA(void *pA)
{
printf("%p!\n",pA);
int *p = pA;
while(1)
{
if(i == 0)
{
i = 1;//lock
*p = 2;
if(5 == *p)
{
printf("=============\n");
}
i = 0;//unlock
}
}
return NULL;
}
void *changeA(void *pA)
{
printf("%p!\n",pA);
int *p = pA;
while(1){
if(i == 0)
{
i = 1;//lock
*p = 5;
if(2 == *p)
{
printf("*************\n");
}
i = 0;//unlock
}
}
return NULL;
}
int main()
{
int a;
a = 1;
int iRet = 0;
iRet = pthread_create(&thread_a_id,NULL,printA,&a);
if(iRet != 0)
{
printf("create failed!\n");
}
iRet = pthread_create(&thread_b_id,NULL,changeA,&a);
if(iRet != 0)
{
printf("create failed!\n");
}
while(1)
{
sleep(5);
}
}
结果打印：
============= ************* ============= ************* ************* ************* ============= ************* ************* ************* ************* ============= ************* ============= ============= ************* ************* ============= ============= ************* ************* ============= ============= ************* ============= =============一塌糊涂，不管用。
这个程序证明了C语言的语句非原子操作，是可以分解成更多更细的指令的，不是一个真正意义上的原语，所以程序连死锁的机会都没有，各种乱跑。
PS：在所谓的lock操作i = 1;后加一个i等于0的判断，就可以知道i也是发生变化的。
while(1)
{
if(i == 0)
{
i = 1;//lock
if(0 == i)
{
printf("..............\n");
}
*p = 2;
if(5 == *p)
{
printf("=============\n");
}
i = 0;//unlock
}
}
最终方法
手动设的普通变量解决不了安全性问题，怎么办？其实，pthread库里是自带方法了。应该是线程锁吧，有指定的变量pthread_mutex_t和指定操作pthread_mutex_lock()、pthread_mutex_unlock()
#include <stdio.h>
#include <pthread.h>
static pthread_t thread_a_id;
static pthread_t thread_b_id;
static int i = 0;
static pthread_mutex_t sMux;
void *printA(void *pA)
{
printf("%p!\n",pA);
int *p = pA;
while(1)
{
pthread_mutex_lock(&(sMux));//lock
*p = 2;
if(5 == *p)
{
printf("=============\n");
}
pthread_mutex_unlock(&(sMux));//unlock
}
return NULL;
}
void *changeA(void *pA)
{
printf("%p!\n",pA);
int *p = pA;
while(1){
pthread_mutex_lock(&(sMux));//lock
*p = 5;
if(2 == *p)
{
printf("*************\n");
}
pthread_mutex_unlock(&(sMux));//unlock
}
return NULL;
}
int main()
{
int a;
a = 1;
int iRet = 0;
iRet = pthread_create(&thread_a_id,NULL,printA,&a);
if(iRet != 0)
{
printf("create failed!\n");
}
iRet = pthread_create(&thread_b_id,NULL,changeA,&a);
if(iRet != 0)
{
printf("create failed!\n");
}
while(1)
{
sleep(5);
}
}
运行结果
[root@jiaxun multi_thread]# ./a.out 0xbfa82be8! 0xbfa82be8!
不再打印多余信息，说明两个线程互相不干扰，不再有安全性问题。
PS:一个线程锁只能互斥保护一个临界资源，这个临界资源其实也不是固定的，全看lock在哪用，其实是一个锁同时只能锁一处资源。
很多不互斥使用的资源，如果用同一个锁，肯定就尴尬了。这就好比你上锁，把自己的锁锁到别人自行车上了，别人拿不了车。这是不想要的结果。
所以要给不同的临界资源陪不同的锁——多初始化一个锁变量，用那个变量去加锁解锁就好了。
测试代码：
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>
#define gettid() syscall(__NR_gettid)
pthread_t thread1;
pthread_t thread2;
pthread_mutex_t lock1;
pthread_mutex_t lock2;
void* pThreadFunc(void * pMutex)
{
//先锁
pthread_mutex_lock((pthread_mutex_t *)pMutex);
printf("the thread's id is %lu\n",gettid());
//再睡
printf("lock,sleep\n");
sleep(10);
printf("sleep over,unlock,exit!\n");
pthread_mutex_unlock((pthread_mutex_t *)pMutex);
return NULL;
}
int main(){
int iRet = 0;
void * status;
//初始化线程锁
pthread_mutex_init(&lock1,NULL);
//先多线程
iRet = pthread_create(&thread1, NULL, pThreadFunc, &lock1); //建立服务线程
if(iRet != 0)
{
return iRet;
}
iRet = pthread_create(&thread2, NULL, pThreadFunc, &lock2); //建立服务线程
if(iRet != 0)
{
return iRet;
}
pthread_join(thread1,&status);
pthread_join(thread2,&status);
}
结果：
# ./a.out the thread's id is 9475 lock,sleep the thread's id is 9476 lock,sleep sleep over,unlock,exit! sleep over,unlock,exit!
# ps -efL | grep ./a.out root 9474 8507 9474 0 3 22:28 pts/1 00:00:00 ./a.out root 9474 8507 9475 0 3 22:28 pts/1 00:00:00 ./a.out root 9474 8507 9476 0 3 22:28 pts/1 00:00:00 ./a.out root 9479 9447 9479 2 1 22:28 pts/2 00:00:00 grep
如果两个线程传同一个线程锁lock1，就会顺序执行：
# ./a.out the thread's id is 9534 lock,sleep sleep over,unlock,exit! the thread's id is 9533 lock,sleep sleep over,unlock,exit!所以，只要 区分好那把锁锁哪辆车就行了。