跟我学Linux编程-13-多线程编程-性能

usleep(1000);
}
void main_thread_task()
{
int i;
int cnt = 0;
while (cnt++ < 100)
{
for (i = 0; i < COUNT_CNT; i++)
{
count_t *c = g_counts + i;
pthread_mutex_lock(&c->m_mutex);
{
count_t *c = g_counts + i;
c->m_cnt[0] = 0;
c->m_cnt[1] = 0;
c->m_cnt[2] = 0;
pthread_mutex_init(&c->m_mutex, NULL);//线程锁一定要初始化
}
//创建两个不同的线程
pthread_create(&thr, NULL, thread_task1, NULL);
for (i = 0; i < COUNT_CNT; i++)
{
count_t *c = g_counts + i;
//当cnt成员累加到CYC_CNT值时，不再对其进行处理
if (c->m_cnt[0] >= CYC_CNT)
{
if (c->m_cnt[0] == CYC_CNT) cnt++;//标识已处理完一个
int pthread_mutex_trylock( pthread_mutex_t *mutex);
可以看到，这两个函数的原型非常想像，功能也比较类似，都是尝试对给定的锁对像进行加锁，如果成功，则线程获得该锁，并返回0；不同点在于当锁已被其他线程占有的情况下，pthread_mutex_lock会阻塞，直至锁被其它线程释放并且本线程获得锁；如pthread_mutex_trylock则不然，如果锁当前已被其他线程占有，则立刻返回失败(非0值)，我们的程序可判读返回值并进行下一步的处理（如处理另一个任务），避免线程被阻塞，从而提高了线程并发度，提升程序性能。我们接下来看例子：
如果程序每次都运行结果都是输出两行thread_task1的信息，最后再输出thread_task2的信息，则结论非常有说服力了，时差根本不是问题，thread_task1与效率就是比thread_task2的高。
那我们来编译和执行程序吧：
gcc thread4.c -o thread4 –lpthread
今天我们重点介绍pthread_mutex_trylock的使用，并通过实例的来展现其用法，探究其提高程序效果的原理。
首先，我们来看pthread_lock与pthread_mutex_trylock的函数原型：
int pthread_mutex_lock(pthread_mutex_t *mutex);
return NULL;
}
void *thread_task2(void *arg)
{
int i;
int cnt = 0;
//保证每个count_t对像的m_cnt[1]值都被累加到指定值CYC_CNT
while (cnt < COUNT_CNT)
{
//依次处理每一个count_t对像
for (i = 0; i < COUNT_CNT; i++)
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
typedef struct
{
int m_cnt[3];
pthread_mutex_t m_mutex;
} count_t;
#define COUNT_CNT20
#define CYC_CNT10000
}
为了展示pthread_mutex_lock与pthread_mutex_trylock的区别，我们写了两个线程执行函数：thread_task1与thread_task2，这两个线程要完成的工作一样，都是处理COUNT_CNT个count_t对像，将每个count_t的计数器m_cnt累加至CYC_CNT，任务完成后，在屏幕上打印一行信息提示我们使命完成，然后线程退出。不同点在于，thread_task1加锁使用的是pthead_mutex_trylock而thread_task2为pthread_mutex_lock。为了制造冲突，我们在主程序中执行了main_thread_task()循环，该循环中，依次对每个count_t对像进行加锁解锁，并在加锁解锁之间使用usleep()函数模拟了一个耗时操作（注意，这里是为了模块耗时操作，在实际编程程中，加锁与解锁之间使用sleep一类的操作，就是自己找麻烦，这在文章的一开头就说过），加大锁冲突的概率。
通过理论分析，我们预期thread_task1会先结束，因此运行程序的结果总是thread_task1先输出，thread_task2后输出。但认真的同学可能认为这个结果不能说明什么原因，因为thread_task1先创建，而thread_task2后创建，这还有个时间差呢，说不定输出信息的先后就是因为这个时间差导致的，与线程效率没有半分钱关系。考虑到这点，我们上两行程序的后面，再用thread_task1创建了第3个线程，代码如下：
c->m_cnt[1]++;
pthread_mutex_unlock(&c->m_mutex);
}
"task 2 done.\n");
return NULL;
}
void count_proc(count_t *c)
{
//模拟一个比较消耗时间的处理操作
c->m_cnt[2] = c->m_cnt[0] * c->m_cnt[1];
count_proc(c);
pthread_mutex_unlock(&c->m_mutex);
}
sleep(10);
}
}
int main(int argc, char *argv[])
{
int i;
pthread_t thr;
//初始化变量
for (i = 0; i < COUNT_CNT; i++)
多线程编程-性能
在上一章节中，我们介绍了线程互斥锁的使用。通过互斥锁，使得每个线程只能串行地运行临界区代码，从而有效地避免了多线程冲突。串行的代码运行方式削弱了多线程并发运行的特性，因此线程锁也潜在地降低了程序性能，如何杜绝线程冲突，又尽可能不影响程序效率，是我们每一个线程从员需要认真考虑的事情。
减少线程性能下降的方法有如下几点:
//创建两个不同的线程
pthread_create(&thr, NULL, thread_task1, NULL);
pthread_create(&thr, NULL, thread_task2, NULL);
//创建另一个thread_task1线程做对比
pthread_create(&thr, NULL, thread_task1, NULL);
{
count_t *c = g_counts + i;
//当cnt成员累加到CYC_CNT值时，不再对其进行处理
if (c->m_cnt[1] >= CYC_CNT)
{
if (c->m_cnt[1] == CYC_CNT) cnt++;//标识已处理完一个
continue;
}
//加锁
pthread_mutex_lock(&c->m_mutex);
continue;
}
//尝试加锁
if (pthread_mutex_trylock(&c->m_mutex))
{
//获取锁失败，跳过处理下一个对像
continue;
}
c->m_cnt[0]++;
pthread_mutex_unlock(&c->m_mutex);
}
usleep(10);
}
printf("task 1 done.\n");
1尽可能减小互斥锁的颗粒，使串行代码的比例减小从而提高效率，这在上一章节末已提过。
2加锁解锁之间的代码，运行时间尽可能减少，避免有sleep或死循环一类的超时等待。
3对不同的冲突资源使用不同的线程锁，避免不相关的线线之间因锁反而产生关联。
4使用pthread_mutex_trylock代替pthread_lock在检测和处理锁冲突，实现单线程对多个对像的非阻塞处理。
在主线程中，我们为thread_task1与thread_task2各创建了一个线程，代码如下：
pthread_create(&thr, NULL, thread_task1, NULL);
pthread_create(&thr, NULL, thread_task2, NULL);
如果两个线程的效率相近，则其标识结束的打印信息应该在同一时间输出(当然，总会有先后，但间隔足够小，多次运行可能这次是你先输出，再另一次是我先输出)，如果效率差别较大，则输出结束信息会有一个较为固定的先后顺序，总是效率高的在前输出，效率低的在后输出。
count_t g_counts[COUNT_CNT];
void *thread_task1(void *arg)
{
int i;
int cnt = 0;