屏障是Linux中协调多个线程并行工作的同步机制，屏障允许每个线程等待直到所有的合作线程到达某一点，然后继续从该点执行，pthread_join是一种屏障但只允许一个线程等待，pthread_barrier允许任意数量的线程等待！

pthread_barrier_init(pthread_barrier_t *屏障，属性，unsigned int 屏障计数值)；

pthread_barrier_wait(pthread_barrier_t *屏障)：在每个线程中调用则计数值加一并将当前线程阻塞在这里，直到计数值达到初始化时设定的值；

线程屏障使用实例：

1、若对一个有800万的数组进行排序，在一个线程中完成需要很长的时间，若采用线程屏障，用8个线程分别对100万个数进行堆排序，然后在主线程中进行merge合并操作，耗时将节省6倍！

2、如下的例子是对一个800万个元素的数组进行初始化，分别采用1、4、8个线程来完成，发现采用8个线程耗时最短。

/*
程序功能：
	创建一个动态数组，给数组赋初值，创建NUM_THREAD个线程，为长度为SIZE的数组初始化，通过(线程屏障同步)
	当所有线程处理完后则打印整个数组的值。通过时间计数来比较所花费的时间。
当采用8个线程时花费sort took 0.0958 seconds
当采用四个线程时
	thread -1249961072 done job.
	thread -1260450928 done job.
	thread -1239471216 done job.
	thread -1270944880 done job.
	sort took 0.1104 seconds
当采用一个线程时
	thread -1239983216 done job.
	sort took 0.2567 seconds
*/
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#define SIZE 8000000L   //数组长度
#define NUM_THREAD 8 //线程个数
#define SIZE_PER (SIZE/NUM_THREAD)//每个线程要处理的数组长度
pthread_barrier_t barrier;//定义屏障
int *a;
/*每个线程的线程处理函数*/
void * thr_fun(void *arg)
{
	long n = (long)arg;	
	long i;
	for(i=n;i<n+SIZE_PER;i++) {
		a[i] = i;
		
	}
	printf("thread %d done job.\n",pthread_self());
	pthread_barrier_wait(&barrier);
	return ((void *)1);
}

int main()
{
	pthread_t tid;
	struct timeval start,end;
	long long startusec,endusec;
	double elapsed;
	int i;
	a = (int *)malloc(SIZE*sizeof(int));  //动态分配数组
	pthread_barrier_init(&barrier,NULL,NUM_THREAD+1);//初始化线程屏障计数为子线程个数加上主线程
	gettimeofday(&start,NULL);//获得起始时间
	for(i=0;i<NUM_THREAD;i++)
	{
		pthread_create(&tid,NULL,thr_fun,(void *)(i*SIZE_PER));//创建子线程
	}
	pthread_barrier_wait(&barrier);//等待所有子线程处理完成
	gettimeofday(&end,NULL);//获得结束时间
	for(i=0;i<SIZE;i++)//打印数组内容
	//printf("%d ",a[i]);
	
	startusec = start.tv_sec * 1000000 +  start.tv_usec;
	endusec = end.tv_sec * 1000000 + end.tv_usec;
	elapsed = (double)(endusec-startusec)/1000000.0;//计算处理所花费的时间
	printf("sort took %.4f seconds\n",elapsed);

	return 0;
}

Linux线程同步------屏障