一、屏障的概念

  • 屏障是用户协调多个线程​并行工作​的同步机制
  • ​工作原理：​屏障允许每个线程等待，直到​所有的合作线程​都到达某一点（屏障），然后从该点继续执行工作

二、屏障变量（pthread_barrier_t）

  • 屏障数据类型：pthread_barrier_t

三、屏障的初始化与释放

#include <pthread.h>
int pthread_barrier_init(pthread_barrier_t *restrict barrier,const pthread_barrierattr_t *restrict attr,unsigned int count);
int pthread_barrier_destroy(pthread_barrier_t *barrier);

// 返回值:成功返回0,否则返回错误编号

​pthread_barrier_init：​

  • ​功能：​对屏障变量进行初始化
  • ​参数：​
  • ​参数1：​初始化的屏障变量
  • ​参数2：​屏障初始化时的属性。如果用默认属性，此处填NULL（屏障属性见文章
  • ​参数3：​用此参数指定，在允许所有线程继续执行之前，必须到达屏障的线程数目。当到达了这个数目之后就可以继续执行

​pthread_barrier_destroy：​

  • ​功能：​屏障变量的反初始化，释放销毁
  • ​参数：​屏障变量
  • 如果在pthread_barrier_destroy之前就释放了读写锁占用的内存空间，那么分配给这个锁的资源就会丢失
  • ​备注（重点）：​此函数只是反初始化屏障变量，并没有释放内存空间，如果屏障变量是通过malloc等函数申请的，那么需要在free掉读屏障变量之前调用pthread_barrier_destroy函数

四、屏障下的等待

#include <pthread.h>
int pthread_barrier_wait(pthread_barrier_t *barrier);

// 返回值:成功返回0或者PTHREAD_BARRIER_SERIAL_THREAD；否则返回错误编号
  • ​功能：​线程调用该函数用来表示自己已经到达了屏障
  • ​工作原理：​如果线程调用这个函数发现屏障的线程计数还未满足要求，那么线程就会进入休眠状态。如果线程调用此函数之后，发现刚好满足屏障计数，那么所有的线程都被唤醒
  • ​返回值的注意事项：​如果一个线程调用该函数返回PTHREAD_BARRIER_SERIAL_THREAD，那么其他在屏障中的线程就返回0.这使得一个线程可以作为主线程，它可以工作在其他所有线程已经完成的工作结果上

五、演示案例

  • 下面演示案例给出了在一个任务上合作的多个线程之间如何用屏障进行同步
#include "apue.h"
#include <pthread.h>
#include <limits.h>
#include <sys/time.h>

#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");
  }
  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\n", elapsed);
  for (i = 0; i < NUMNUM; i++)
    printf("%ld\n", snums[i]);
  exit(0);
}

APUE编程：64---线程处理（屏障：pthread_barrier_t）_屏障