Linux/Unix 编程中 POSIX 函数的线程安全问题

int sum(int i, int j) {
return (i+j);
}

static int sum_invoke_counter = 0;

void inc_sum_counter(int i, int j) {
sum_invoke_counter++;
}

int sum(int i, int j) {
inc_sum_counter();
return (i+j);
}

static int sum_invoke_counter = 0;
static pthread_mutex_t sum_invoke_counter_lock = PTHREAD_MUTEX_INITIALIZER;

void inc_sum_counter(int i, int j) {
pthread_mutex_lock( &sum_invoke_counter_lock );
sum_invoke_counter++;
pthread_mutex_unlock( &sum_invoke_counter_lock );
}

int sum(int i, int j) {
inc_sum_counter();
return (i+j);
}

#include <unistd.h>
#include <stdio.h>
#include <stdarg.h>
#include <pthread.h>
#include <string.h>
#include <libgen.h>

void printf_sa(char *fmt, ...) {
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
va_list args;

va_start(args, fmt);
pthread_mutex_lock(&lock);
vprintf(fmt, args);
pthread_mutex_unlock(&lock);
va_end(args);
}

void* basename_test(void *arg) {
pthread_t self = pthread_self();
char *base = basename((char*)arg);
printf_sa("TI-%u: base: %s\n", self, base);
}

int main(int argc, char *argv) {

int i = 0;
pthread_t tids[2];
char msg[1024];
strcpy(msg, "/tmp/test");

pthread_create(&tids[0], NULL, basename_test, msg);
msg[7] -= 32;
pthread_create(&tids[1], NULL, basename_test, msg);

pthread_join(tids[0], NULL);
pthread_join(tids[1], NULL);
return 0;
}

TI-3086846864: base: teSt
TI-3076357008: base: teSt

TI-3086846864: base: test
TI-3076357008: base: teSt

/* thread-safe version of basename() */
char* basename_ta(char *path, char *buf, int buflen) {

#define DEFAULT_RESULT_DOT     "."
#define DEFAULT_RESULT_SLASH   "/"

/* 如果输入的路径长度小于 PATH_MAX，
* 则使用自动变量 i_fixed_bufer 作为内部缓冲区 ,
* 否则申请堆内存做为字符串存放缓冲区。
*/

char i_fixed_buf[PATH_MAX+1];
const int i_fixed_buf_len = sizeof(i_fixed_buf)/sizeof(char);

char *result = buf;
char *i_buf = NULL;
int i_buf_len = 0;

int adjusted_path_len = 0;
int path_len = 0;

int i, j;
char tmp = 0;

if (path == NULL) {
/* 如果输入为空指针，则直接返回当前目录 */
path = DEFAULT_RESULT_DOT;
}

/* 分配内部缓冲区用来存放输入字符串 */
path_len = strlen(path);
if ((path_len + 1) > i_fixed_buf_len) {
i_buf_len = (path_len + 1);
i_buf = (char*) malloc(i_buf_len * sizeof(char));
} else {
i_buf_len = i_fixed_buf_len;
i_buf = i_fixed_buf;
}

/* 拷贝字符串到缓冲区，以便接下来对字符串做预处理 */
strcpy(i_buf, path);
adjusted_path_len = path_len;

/* 预处理：删除路径未的路径符号 '/'; */
if (adjusted_path_len > 1) {
while (i_buf[adjusted_path_len-1] == '/') {
if (adjusted_path_len != 1) {
adjusted_path_len--;
} else {
break;
}
}
i_buf[adjusted_path_len] = '\0';
}

/* 预处理：折叠最后出现的连续 '/'; */
if (adjusted_path_len > 1) {

for (i = (adjusted_path_len -1), j = 0; i >= 0; i--) {
if (j == 0) {
if (i_buf[i] == '/')
j = i;
} else {
if (i_buf[i] != '/') {
i++;
break;
}
}
}

if (j != 0 && i < j) {
/* 折叠多余的路径符号 '/';
*/
strcpy(i_buf+i, i_buf+j);
}

adjusted_path_len -= (j - i);
}

/* 预处理：寻找最后一个路径符号 '/' */
for (i = 0, j = -1; i < adjusted_path_len; i++) {
if (i_buf[i] == '/')
j = i;
}

/* 查找 basename */
if (j >= 0) {

/* found one '/' */
if (adjusted_path_len == 1) {  /* 输入的是跟路径 ("/")，则返回根路径 */
if (2 > buflen) {
return NULL;
} else {
strcpy(result, DEFAULT_RESULT_SLASH);
}
} else {
if ((adjusted_path_len - j) > buflen) {  /* 缓冲区不够，返回空指针 */
result = NULL;
} else {
strcpy(result, (i_buf+j+1));
}
}

} else {

/* no '/' found  */
if (adjusted_path_len == 0) {
if (2 > buflen) {              /* 如果传入的参数为空字符串 ("") */
return NULL;                /* 直接返回当前目录 (".")  */
} else {
strcpy(result, DEFAULT_RESULT_DOT);
}
} else {
if ((adjusted_path_len+1) > buflen) {
result = NULL;             /* 缓冲区不够，返回空指针    */
} else {
strcpy(result, i_buf);   /* 拷贝整个字符串做为返回值   */
}
}
}

if (i_buf_len != i_fixed_buf_len) {   /* 释放缓冲区         */
free(i_buf);
i_buf = NULL;
}

return result;
}