高级Linux程序设计第四章：线程-CSDN博客

要想使用POSIX标准线程API(pthreads)，需要连接libpthread.so库到程序中。

1、创建线程

进程中的每个线程都有一个线程号，类型为pthread_t。
用pthread_self函数可以返回当前线程的线程号。
线程号之间的比较可以用函数pthread_equal。

if (!pthread_equal (pthread_self (), other_thread))

pthread_join (other_thread, NULL);

每个线程执行一个线程函数：

void * function(void *)

用函数pthread_create函数可以创建一个线程：
- 第一个参数是一个pthread_t类型的变量的指针，用于存储线程号。
- 第二个参数是一个pthread_attr_t类型的线程属性对象，NULL表示使用默认属性
- 第三个参数是一个指向线程函数的指针
- 第四个参数是void指针，指向传给线程的参数
编译并链接程序：

% cc -o thread-create thread-create.c –lpthread

线程退出有两种方式：
- 线程函数退出。线程函数的返回值就是线程的返回值。
- 显式调用pthread_exit，其参数为线程的返回值。

#include <pthread.h>

#include <stdio.h>

/* Prints x’s to stderr. The parameter is unused. Does not return. */

void* print_xs (void* unused)

{

while (1)

fputc (‘x’, stderr);

return NULL;

}

/* The main program. */

int main ()

{

pthread_t thread_id;

/* Create a new thread. The new thread will run the print_xs function. */

pthread_create (&thread_id, NULL, &print_xs, NULL);

/* Print o’s continuously to stderr. */

while (1)

fputc (‘o’, stderr);

return 0;

}

1.1、向线程传递数据

Listing 4.2 (thread-create2) Create Two Threads

#include <pthread.h>

#include <stdio.h>

/* Parameters to print_function. */

struct char_print_parms

{

/* The character to print. */

char character;

/* The number of times to print it. */

int count;

};

/* Prints a number of characters to stderr, as given by PARAMETERS,

which is a pointer to a struct char_print_parms. */

void* char_print (void* parameters)

{

/* Cast the cookie pointer to the right type. */

struct char_print_parms* p = (struct char_print_parms*) parameters;

int i;

for (i = 0; i < p->count; ++i)

fputc (p->character, stderr);

return NULL;

}

/* The main program. */

int main ()

{

pthread_t thread1_id;

pthread_t thread2_id;

struct char_print_parms thread1_args;

struct char_print_parms thread2_args;

/* Create a new thread to print 30,000 ’x’s. */

thread1_args.character = ’x’;

thread1_args.count = 30000;

pthread_create (&thread1_id, NULL, &char_print, &thread1_args);

/* Create a new thread to print 20,000 o’s. */

thread2_args.character = ’o’;

thread2_args.count = 20000;

pthread_create (&thread2_id, NULL, &char_print, &thread2_args);

return 0;

}

此程序有一个Bug，主线程创建线程的时候，穿进去的参数是局部变量，如果主线程在从线程之前退出，则局部变量会被释放，然而从线程却可能仍然要访问这些变量，就会出错。因而应该应用join使得主线程等待从线程结束。

1.2、Join线程

phread_join有两个参数：
- 第一个参数是要join的线程号。
- 第二个参数是一个void指针，指向一个变量来接收线程的返回值。

Revised Main Function for thread-create2.c

int main ()

{

pthread_t thread1_id;

pthread_t thread2_id;

struct char_print_parms thread1_args;

struct char_print_parms thread2_args;

/* Create a new thread to print 30,000 x’s. */

thread1_args.character = ’x’;

thread1_args.count = 30000;

pthread_create (&thread1_id, NULL, &char_print, &thread1_args);

/* Create a new thread to print 20,000 o’s. */

thread2_args.character = ’o’;

thread2_args.count = 20000;

pthread_create (&thread2_id, NULL, &char_print, &thread2_args);

/* Make sure the first thread has finished. */

pthread_join (thread1_id, NULL);

/* Make sure the second thread has finished. */

pthread_join (thread2_id, NULL);

/* Now we can safely return. */

return 0;

}

1.3、线程返回值

用线程计算素数

#include <pthread.h>

#include <stdio.h>

/* Compute successive prime numbers (very inefficiently). Return the

Nth prime number, where N is the value pointed to by *ARG. */

void* compute_prime (void* arg)

{

int candidate = 2;

int n = *((int*) arg);

while (1) {

int factor;

int is_prime = 1;

/* Test primality by successive division. */

for (factor = 2; factor < candidate; ++factor)

if (candidate % factor == 0) {

is_prime = 0;

break;

}

/* Is this the prime number we’re looking for? */

if (is_prime) {

if (--n == 0)

/* Return the desired prime number as the thread return value. */

return (void*) candidate;

}

++candidate;

}

return NULL;

}

int main ()

{

pthread_t thread;

int which_prime = 5000;

int prime;

/* Start the computing thread, up to the 5,000th prime number. */

pthread_create (&thread, NULL, &compute_prime, &which_prime);

/* Do some other work here... */

/* Wait for the prime number thread to complete, and get the result. */

pthread_join (thread, (void*) &prime);

/* Print the largest prime it computed. */

printf(“The %dth prime number is %d.\n”, which_prime, prime);

return 0;

}

1.4、线程属性

使用线程属性：
- 创建pthread_attr_t对象。
- 调用pthread_attr_init来初始化为默认属性。
- 可以修改线程属性对象，设置需要的属性值。
- 调用pthread_create的时候将属性对象指针传入。
- 调用pthread_attr_destroy来释放属性对象。
- pthread_attr_t本身不能自动回收，但是可以用pthread_attr_init函数重新初始化线程对象。
使用detach state属性
- 一个线程可以默认状态下被创建称为可join的线程，也可以创建为detached线程。
- 一个可join的线程在结束后不会自动被回收，而是要其他线程调用pthread_join来获得此线程的返回值。
- 一个detached线程在结束后会自动被回收。
- 用函数pthread_attr_setdetachstate来设定线程属性对象的detach state.

#include <pthread.h>

void* thread_function (void* thread_arg)

{

/* Do work here... */

}

int main ()

{

pthread_attr_t attr;

pthread_t thread;

pthread_attr_init (&attr);

pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);

pthread_create (&thread, &attr, &thread_function, NULL);

pthread_attr_destroy (&attr);

/* Do work here... */

/* No need to join the second thread. */

return 0;

}

2、取消线程

一个线程可以调用pthread_cancel来取消另一个线程。
被取消的线程需要被join来释放资源。
被取消的线程的返回值为PTHREAD_CANCELED
有关线程的取消，一个线程可以为如下三个状态：
- 可异步取消：一个线程可以在任何时刻被取消。
- 可同步取消：取消的请求被放在队列中，直到线程到达某个点，才被取消。
- 不可取消：取消的请求被忽略。
- 默认状态下，线程是可同步取消的。
调用pthread_setcanceltype来设定线程取消的方式：
- pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
- pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, NULL);
- pthread_setcanceltype (PTHREAD_CANCEL_DISABLE, NULL);

3、线程私有数据

每个线程私有数据都有一个key
每个线程都使用此key来访问属于它的那份数据。
调用pthread_key_create来为此线程创建一个新的key和数据。
- 第一个参数是pthread_key_t
- 第二个参数是一个回收函数，会在线程退出的时候被调用。
每个线程可以调用pthread_setspecific，根据key来设定线程私有数据的值。
调用pthread_getspecific来得到一个线程私有数据。

#include <malloc.h>

#include <pthread.h>

#include <stdio.h>

/* The key used to associate a log file pointer with each thread. */

static pthread_key_t thread_log_key;

/* Write MESSAGE to the log file for the current thread. */

void write_to_thread_log (const char* message)

{

FILE* thread_log = (FILE*) pthread_getspecific (thread_log_key);

fprintf (thread_log, “%s\n”, message);

}

/* Close the log file pointer THREAD_LOG. */

void close_thread_log (void* thread_log)

{

fclose ((FILE*) thread_log);

}

void* thread_function (void* args)

{

char thread_log_filename[20];

FILE* thread_log;

/* Generate the filename for this thread’s log file. */

sprintf (thread_log_filename, “thread%d.log”, (int) pthread_self ());

/* Open the log file. */

thread_log = fopen (thread_log_filename, “w”);

/* Store the file pointer in thread-specific data under thread_log_key. */

pthread_setspecific (thread_log_key, thread_log);

write_to_thread_log (“Thread starting.”);

/* Do work here... */

return NULL;

}

int main ()

{

int i;

pthread_t threads[5];

/* Create a key to associate thread log file pointers in thread-specific data. Use close_thread_log to clean up the file

pointers. */

pthread_key_create (&thread_log_key, close_thread_log);

/* Create threads to do the work. */

for (i = 0; i < 5; ++i)

pthread_create (&(threads[i]), NULL, thread_function, NULL);

/* Wait for all threads to finish. */

for (i = 0; i < 5; ++i)

pthread_join (threads[i], NULL);

return 0;

}

3.1、线程回收

Linux可以提供回收器(cleanup handler)，它是一个函数，在线程退出的时候被调用。

调用pthread_cleanup_push可以注册一个回收器。

调用pthread_cleanup_pop可以注销一个回收器。

pthread_cleanup_pop(0)仅仅注销一个回收器。

pthread_cleanup_pop(1)不仅仅注销这个回收器，而且调用它。

#include <malloc.h>

#include <pthread.h>

/* Allocate a temporary buffer. */

void* allocate_buffer (size_t size)

{

return malloc (size);

}

/* Deallocate a temporary buffer. */

void deallocate_buffer (void* buffer)

{

free (buffer);

}

void do_some_work ()

{

/* Allocate a temporary buffer. */

void* temp_buffer = allocate_buffer (1024);

/* Register a cleanup handler for this buffer, to deallocate it in case the thread exits or is cancelled. */

pthread_cleanup_push (deallocate_buffer, temp_buffer);

/* Do some work here that might call pthread_exit or might be cancelled... */

/* Unregister the cleanup handler. Because we pass a nonzero value, this actually performs the cleanup by calling

deallocate_buffer. */

pthread_cleanup_pop (1);

}

4、线程同步及临界区

4.1、互斥锁(Mutexes)

Mutex全称MUTual EXclusion lock，也即互斥锁。
同一时刻，只有一个线程可以访问互斥锁。
调用pthread_mutex_init可以创建互斥锁：
- 第一个参数是pthread_mutex_t
- 第二个参数是互斥锁属性对象，设为NULL表示使用默认属性。

pthread_mutex_t mutex;

pthread_mutex_init (&mutex, NULL);

创建互斥锁的第二种方式：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
调用pthread_mutex_lock来锁定互斥锁。
调用pthread_mutex_unlock来解锁互斥锁。

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <pthread.h>

struct job

{

struct job* next;

int value;

};

struct job* job_queue;

void process_job(struct job*);

pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;

void * process_queue_function (void * arg)

{

while(1)

{

struct job* next_job;

pthread_mutex_lock(&job_queue_mutex);

if(job_queue == NULL)

next_job = NULL;

else

{

printf("begin removing a job...\n");

next_job = job_queue;

job_queue = job_queue->next;

printf("after removing a job...\n");

}

pthread_mutex_unlock(&job_queue_mutex);

if(next_job == NULL)

{

sleep(5);

continue;

}

process_job(next_job);

free(next_job);

}

return NULL;

}

void process_job(struct job* p)

{

printf("The value is : %d.\n", p->value);

}

void enqueue_job(struct job* new_job)

{

pthread_mutex_lock(&job_queue_mutex);

printf("begin inserting a job...\n");

new_job->next = job_queue;

job_queue = new_job;

printf("after inserting a job...\n");

pthread_mutex_unlock(&job_queue_mutex);

}

void * insert_queue_function(void * arg)

{

int i = 0;

while(i < 20)

{

sleep(1);

printf("put the value: %d.\n", i);

struct job* new_job = (struct job*)malloc(sizeof(struct job));

new_job->next = NULL;

new_job->value = i;

enqueue_job(new_job);

i++;

}

int main()

{

pthread_t insert_thread, process_thread;

pthread_create(&insert_thread, NULL, &insert_queue_function, NULL);

pthread_create(&process_thread, NULL, &process_queue_function, NULL);

pthread_join(insert_thread, NULL);

pthread_join(process_thread, NULL);

}

互斥锁有三种：
- 默认是快锁(fast mutex)：两次锁定互斥锁会造成死锁。
- 递归锁(recursive mutex)：允许多次锁定互斥锁，同样次数的解锁可以解除互斥锁。
- 检错锁(error checking mutex)：第二次锁定互斥锁将返回错误码EDEADLK
使用互斥锁属性对象可