31、深入理解计算机系统笔记，并发编程（concurrent）（3）

1、基于预线程化（prethreading）的并发服务器

常规的并发服务器中，我们为每一个客户端创建一个新线程，代价较大。一个基于预线程化的服务器通过使用“生产者－消费者模型”来试图降低这种开销。





服务器由一个主线程和一组worker线程组成的，主线程不断地接受来自客户端的连接请求，并将得到的连接描述符放在一个共享的缓冲区中。每一个worker线程反复从共享缓冲区中取出描述符，为客户端服务，然后等待下一个描述符。

示例代码

/*
* echoservert_pre.c - A prethreaded concurrent echo server
*/
/* $begin echoservertpremain */
#include "csapp.h"
#include "sbuf.h"
#define NTHREADS  4
#define SBUFSIZE  16

void echo_cnt(int connfd);
void *thread(void *vargp);

sbuf_t sbuf; /* shared buffer of connected descriptors */

int main(int argc, char **argv)
{
int i, listenfd, connfd, port, clientlen=sizeof(struct sockaddr_in);
struct sockaddr_in clientaddr;
pthread_t tid;

if (argc != 2) {
fprintf(stderr, "usage: %s <port>\n", argv[0]);
exit(0);
}
port = atoi(argv[1]);
sbuf_init(&sbuf, SBUFSIZE);
listenfd = Open_listenfd(port);

for (i = 0; i < NTHREADS; i++)  /* Create worker threads */
Pthread_create(&tid, NULL, thread, NULL);

while (1) {
connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen);
sbuf_insert(&sbuf, connfd); /* Insert connfd in buffer */
}
}

void *thread(void *vargp)
{
Pthread_detach(pthread_self());
while (1) {
int connfd = sbuf_remove(&sbuf); /* Remove connfd from buffer */
echo_cnt(connfd);                /* Service client */
Close(connfd);
}
}
/* $end echoservertpremain */

如上模型组成事件驱动服务器，事件驱动程序创建它们自己的并发逻辑流，这些逻辑流被模型化为状态机，带有主线程和worker线程的简单状态机。

2、其他并发问题

一个函数被称为线程安全（thread-safe）的，当且仅当多个线程反复地调用时，它会一下产生正确的结果。

下面是四类不安全（相交）的函数：

1）不保护共享变量的函数

利用P，V操作解决这个问题。

2）保持跨越多个调用的状态的函数

示例代码1

#include <stdio.h>

/* $begin rand */
unsigned int next = 1;

/* rand - return pseudo-random integer on 0..32767 */
int rand(void)
{
next = next*1103515245 + 12345;
return (unsigned int)(next/65536) % 32768;
}

/* srand - set seed for rand() */
void srand(unsigned int seed)
{
next = seed;
}
/* $end rand */

int main()
{
srand(100);
printf("%d\n", rand());
printf("%d\n", rand());
printf("%d\n", rand());
exit(0);
}

srand设置种子，调用rand生成随机数。多线程调用时就出问题了。我们可以重写之解决，使之不再使用任何静态数据，取而代之地依靠调用者在参数中传递状态信息。

示例代码2

#include <stdio.h>

/* $begin rand_r */
/* rand_r - a reentrant pseudo-random integer on 0..32767 */
int rand_r(unsigned int *nextp)
{
*nextp = *nextp * 1103515245 + 12345;
return (unsigned int)(*nextp / 65536) % 32768;
}
/* $end rand_r */

int main()
{
unsigned int next = 1;

printf("%d\n", rand_r(&next));
printf("%d\n", rand_r(&next));
printf("%d\n", rand_r(&next));
exit(0);
}

3）返回指向静态变量的指针的函数

某些函数（如gethostbyname）将结果放在静态结构中，并返回一个指向这个结构的指针。多线程并发可能引发灾难，因为正在被一个线程使用的结果会被另一个线程悄悄覆盖。

两种方法处理：

一是重写之。使得调用者传递存放结果的结构的地址，这就消除了共享数据。

第二种方法是：使用称为lock-and-copy的技术。在每一个调用位置，对互斥锁加锁，调用线程不安全函数，动态地为结果分配存储器，copy函数返回结果到这个存储器位置，对互斥锁解锁。

示例代码3

/*
* gethostbyname_ts - A thread-safe wrapper for gethostbyname
*/
#include "csapp.h"

static sem_t mutex; /* protects calls to gethostbyname */

static void init_gethostbyname_ts(void)
{
Sem_init(&mutex, 0, 1);
}

/* $begin gethostbyname_ts */
struct hostent *gethostbyname_ts(char *hostname)
{
struct hostent *sharedp, *unsharedp;

unsharedp = Malloc(sizeof(struct hostent));
P(&mutex);
sharedp = gethostbyname(hostname);
*unsharedp = *sharedp; /* copy shared struct to private struct */
V(&mutex);
return unsharedp;
}
/* $end gethostbyname_ts */

int main(int argc, char **argv)
{
char **pp;
struct in_addr addr;
struct hostent *hostp;

if (argc != 2) {
fprintf(stderr, "usage: %s <hostname>\n", argv[0]);
exit(0);
}

init_gethostbyname_ts();
hostp = gethostbyname_ts(argv[1]);
if (hostp) {
printf("official hostname: %s\n", hostp->h_name);
for (pp = hostp->h_aliases; *pp != NULL; pp++)
printf("alias: %s\n", *pp);
for (pp = hostp->h_addr_list; *pp != NULL; pp++) {
addr.s_addr = *((unsigned int *)*pp);
printf("address: %s\n", inet_ntoa(addr));
}
}
else {
printf("host %s not found\n", argv[1]);
}
exit(0);
}

4）调用线程不安全函数的函数

f调用g。如果g是2）类函数，则f也是不安全的，只能得写。如果g是1）或3）类函数，则利用互斥锁保护调用位置和任何想得到的共享数据，f仍是线程安全的。如上例中。

3、可重入性

可重入函数（reenterant function）具有这样的属性：当它们被多个线程调用时，不会引用任何共享数据。





可重入函数通常比不可重入函数高效一些，因为不需要同步操作。

如果所有的函数参数都是传值传递（没有指针），且所有的数据引用都是本地的自动栈变量（没有引用静态或全局变量），则函数是显式可重入的，无论如何调用，都没有问题。

允许显式可重入函数中部分参数用指针传递，则隐式可重入的。在调用线程时小心传递指向非共享数据的指针，它才是可重入。如rand_r。

可重入性同时是调用者和被调用者的属性。

4、C库中常用的线程不安全函数及unix线程安全版本





5、竞争

当一个程序的正确性依赖于一个线程要在另一个线程到达y点之前到达它的控制流中的x点时，就会发生竞争(race)。

示例代码1

/*
* race.c - demonstrates a race condition
*/
/* $begin race */
#include "csapp.h"
#define N 4

void *thread(void *vargp);

int main()
{
pthread_t tid
;
int i;

for (i = 0; i < N; i++)
Pthread_create(&tid[i], NULL, thread, &i);
for (i = 0; i < N; i++)
Pthread_join(tid[i], NULL);
exit(0);
}

/* thread routine */
void *thread(void *vargp)
{
int myid = *((int *)vargp);
printf("Hello from thread %d\n", myid);
return NULL;
}
/* $end race */

示例代码2（消除竞争）

/*
* norace.c - fixes the race in race.c
*/
/* $begin norace */
#include "csapp.h"
#define N 4

void *thread(void *vargp);

int main()
{
pthread_t tid
;
int i, *ptr;

for (i = 0; i < N; i++) {
ptr = Malloc(sizeof(int));
*ptr = i;
Pthread_create(&tid[i], NULL, thread, ptr);
}
for (i = 0; i < N; i++)
Pthread_join(tid[i], NULL);
exit(0);
}

/* thread routine */
void *thread(void *vargp)
{
int myid = *((int *)vargp);
Free(vargp);
printf("Hello from thread %d\n", myid);
return NULL;
}
/* $end norace */

6、死锁

信号量引入一个潜在的运行是错误－死锁。死锁是因为每个线程都在等待其他线程运行一个根本不可能发生的V操作。

避免死锁是很困难的。当使用二进制信号量来实现互斥时，可以用如下规则避免：

如果用于程序中每对互斥锁（s,t），每个既包含s也包含t的线程都按照相同顺序同时对它们加锁，则程序是无死锁的。

参考

[1] /article/4743483.html