屏障和屏障属性

屏障(barrier)是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待，直到所有的合作
线程到达某一点，然后从该点继续执行。我们已经看到了一种屏障，pthread_join函数就是一种屏

障，允许一个线程等待，直到另一个线程退出。
但是屏障对象的概念更广。他们允许任意数量的线程等待，直到所有的线程完成处理工作，而线程
不需要退出。所有线程达到屏障后可以接着工作。
可以用pthrad_barrier_init函数对屏障进行初始化，用pthread_barrier_destroy函数反初始化。
#include<pthread.h>
int pthread_barrier_init(pthread_barrier_t *restrict barrier,const 

pthread_barrierattrt_t *restrict attr,unsigned int count);

int pthread_barrier_destory(pthread_barrier_t *barrier);
两个函数返回的返回值：若成功，返回0，否则，返回错误编号
初始化屏障时，可以使用count参数指定，在允许所有的线程继续运行之前，必须达到屏障的线程数

目。使用attr参数指定屏障对象的属性，我们会在下一章讨论。现在设置attr为NULL,用默认属性
初始化屏障。如果使用pthread_barrier_init函数为屏障分配资源，那么在反初始化屏障时可以
调用pthread_barrier_destroy函数释放相应的资源。
可以使用pthread_barrier_wait函数表明，线程已完成工作，准备等待所有其他线程赶上来。
#include<pthread.h>
int pthread_barrier_wait(pthread_barrier_t *barrier);
返回值：若成功，返回0或者PTHREAD_BARRIER_SERIAL_THREAD;否则，返回错误编码。
调用pthread_barrier_wait的线程在屏障计数（调用pthread_barrier_init时设定）未满足
条件时，会进入休眠状态。如果该线程是最后一个调用pthread_barrier_wait的线程，就满足了
屏障计数，所有的线程都被唤醒。
对于一个任意线程，pthread_barrier_wait函数返回PTHREAD_BARRIER_SERIAL_THREAD。
剩下的线程看到的返回值是0.这使得一个线程作为主线程，它可以工作在其他所有线程已完成的工

作结果上。
一旦达到屏障计数值，而且线程处于非阻塞状态，屏障就可以被重新调用。但是除非在
调用了pthread_barrier_destroy函数之后，又调用了pthread_barrier_init函数对计数用另外的
的数进行初始化，否则屏障计数不会改变。

//这个例子给出了在一个任务上合作的多个线程之间如何用屏障进行同步
#include "apue.h"
#include <pthread.h>
#include <limits.h>
#include <sys/time.h>
#include<stdio.h>
#define SOLARIS
#define NTHR   8                /* number of threads */
#define NUMNUM 8000000L            /* number of numbers to sort */
#define TNUM   (NUMNUM/NTHR)    /* number to sort per thread */

long nums[NUMNUM];
long snums[NUMNUM];

pthread_barrier_t b;

#ifdef SOLARIS
#define heapsort qsort
#else
extern int heapsort(void *, size_t, size_t,
                    int (*)(const void *, const void *));
#endif

/*
 * Compare two long integers (helper function for heapsort)
 */
int
complong(const void *arg1, const void *arg2)
{
    long l1 = *(long *)arg1;
    long l2 = *(long *)arg2;

    if (l1 == l2)
        return 0;
    else if (l1 < l2)
        return -1;
    else
        return 1;
}

/*
 * Worker thread to sort a portion of the set of numbers.
 */
void *
thr_fn(void *arg)
{
    long    idx = (long)arg;

    heapsort(&nums[idx], TNUM, sizeof(long), complong);
    pthread_barrier_wait(&b);

    /*
     * Go off and perform more work ...
     */
    return((void *)0);
}

/*
 * Merge the results of the individual sorted ranges.
 */
void
merge()
{
    long    idx[NTHR];
    long    i, minidx, sidx, num;

    for (i = 0; i < NTHR; i++)
        idx[i] = i * TNUM;
    for (sidx = 0; sidx < NUMNUM; sidx++) {
        num = LONG_MAX;
        for (i = 0; i < NTHR; i++) {
            if ((idx[i] < (i+1)*TNUM) && (nums[idx[i]] < num)) {
                num = nums[idx[i]];
                minidx = i;
            }
        }
        snums[sidx] = nums[idx[minidx]];
        idx[minidx]++;
    }
}

int
main()
{
    unsigned long    i;
    struct timeval    start, end;
    long long        startusec, endusec;
    double            elapsed;
    int                err;
    pthread_t        tid;

    /*
     * Create the initial set of numbers to sort.
     */
    srandom(1);
    for (i = 0; i < NUMNUM; i++)
        nums[i] = random();

    /*
     * Create 8 threads to sort the numbers.
     */
    gettimeofday(&start, NULL);
    pthread_barrier_init(&b, NULL, NTHR+1);
    for (i = 0; i < NTHR; i++) {
        err = pthread_create(&tid, NULL, thr_fn, (void *)(i * TNUM));
        if (err != 0)
            //err_exit(err, "can't create thread");
            printf("can't create thread
");
    }
    pthread_barrier_wait(&b);
    merge();
    gettimeofday(&end, NULL);

    /*
     * Print the sorted list.
     */
    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
", elapsed);
    for (i = 0; i < NUMNUM; i++)
        printf("%ld
", snums[i]);
    exit(0);
}

这个例子给出了多个线程只执行一个任务时，使用屏障的最简单情况。在更加实际的情况下，工作

线程在调用pthread_barrier_wait函数返回后会继续接着执行其他活动。
在这个实例中，使用了8个线程分解了800万个数的排序工作。每个线程用堆排序算法对100万个数进

行排序。然后主线程调用一个函数对这些结果进行合并。
并不需要使用pthread_barrier_wait函数中的返回值PTHREAD_BARRIER_SERIAL_THREAD来决定
那个线程执行结果合并操作，因为我们使用了主线程来完成这个任务。这也是把屏障计数值设为工

作线程加1的原因，主线程也作为其中的一个候选线程。

屏障属性
屏障也有属性。可以使用pthread_barrierattr_init函数对屏障属性对象进行初始化，用
pthread_barrierattr_destroy函数对屏障属性对象进行初始化。
#include<pthread.h>
int pthread_barrierattr_init(pthread_barrierattr_t *attr);
int pthread_barrierattr_destroy(pthread_barrierattr_t *attr);
两个函数的返回值：若成功，返回0；否则，返回错误编码
目前定义的屏障属性只有进程共享属性，它控制着屏障是可以被多进程的线程使用，还是只能被
初始化屏障的进程内的多线程使用。与其他属性对象一样，有一个获得属性值的函数

（pthread_barrierattr_getpshared）和一个设置属性值的函数

（pthread_barrierattr_setpshared).
进程共享属性的值可以是PTHREAD_PROCESS_SHARED(多进程中的多个线程可用），也可以是

PTHREAD_PROCESS_PRIVATE（只有初始化屏障的那个进程内的多个线程可用）。