多线程技术

你的名字 2022-04-15 01:43 221阅读 0赞

进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。

线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows系统。主执行线程终止了，进程也就随之终止。

每一个进程至少有一个主执行线程，它无需由用户去主动创建，是由系统自动创建的。用户根据需要在应用程序中创建其它线程，多个线程并发地运行于同一个进程中。一个进程中的所有线程都在该进程的虚拟地址空间中，共同使用这些虚拟地址空间、全局变量和系统资源，所以线程间的通讯非常方便，多线程技术的应用也较为广泛。多线程可以实现并行处理，避免了某项任务长时间占用CPU时间。要说明的一点是，目前大多数的计算机都是单处理器（CPU）的，为了运行所有这些线程，操作系统为每个独立线程安排一些CPU时间，操作系统以轮换方式向线程提供时间片，这就给人一种假象，好象这些线程都在同时运行。由此可见，如果两个非常活跃的线程为了抢夺对CPU的控制权，在线程切换时会消耗很多的CPU资源，反而会降低系统的性能。这一点在多线程编程时应该注意。

一个采用了多线程技术的应用程序可以更好地利用系统资源。其主要优势在于充分利用了CPU的空闲时间片，可以用尽可能少的时间来对用户的要求做出响应，使得进程的整体运行效率得到较大提高，同时增强了应用程序的灵活性。更为重要的是，由于同一进程的所有线程是共享同一内存，所以不需要特殊的数据传送机制，不需要建立共享存储区或共享文件，从而使得不同任务之间的协调操作与运行、数据的交互、资源的分配等问题更加易于解决。

在多线程应用中，考虑不同线程之间的数据同步和防止死锁。当两个或多个线程之间同时等待对方释放资源的时候就会形成线程之间的死锁。为了防止死锁的发生，需要通过同步来实现线程安全。  
临界区（CCriticalSection）  
事件（CEvent）  
互斥量（CMutex）  
信号量（CSemaphore）

POSIX thread 简称为pthread，Posix线程是一个POSIX标准线程.该标准定义内部API创建和操纵线程.  
线程库实行了POSIX线程标准通常称为pthreads.pthreads是最常用的POSIX系统如Linux和Unix,而微软Windowsimplementations同时存在  
Pthreads定义了一套 C程序语言类型、函数与常量，它以 pthread.h 头文件和一个线程库实现。  
**数据类型**  
pthread\_t：线程句柄 　  
pthread\_attr\_t：线程属性  
**线程操纵函数**  
pthread\_create()：创建一个线程 　　  
pthread\_exit()：终止当前线程 　　  
pthread\_cancel()：中断另外一个线程的运行 　　  
pthread\_join()：阻塞当前的线程，直到另外一个线程运行结束 　　  
pthread\_attr\_init()：初始化线程的属性 　　  
pthread\_attr\_setdetachstate()：设置脱离状态的属性（决定这个线程在终止时是否可以被结合）  
pthread\_attr\_getdetachstate()：获取脱离状态的属性 　　  
pthread\_attr\_destroy()：删除线程的属性 　　  
pthread\_kill()：向线程发送一个信号  
**同步函数**  
用于 mutex 和条件变量 　　  
pthread\_mutex\_init() 初始化互斥锁 　　  
pthread\_mutex\_destroy() 删除互斥锁 　　  
pthread\_mutex\_lock()：占有互斥锁（阻塞操作） 　　  
pthread\_mutex\_trylock()：试图占有互斥锁（不阻塞操作）。当互斥锁空闲时将占有该锁；否则立即返回　　  
pthread\_mutex\_unlock(): 释放互斥锁 　　  
pthread\_cond\_init()：初始化条件变量 　　  
pthread\_cond\_destroy()：销毁条件变量 　　  
pthread\_cond\_wait(): 等待条件变量的特殊条件发生  
pthread\_cond\_signal(): 唤醒第一个调用pthread\_cond\_wait()而进入睡眠的线程 　  
Thread-local storage（或者以Pthreads术语，称作 线程特有数据）: 　　  
pthread\_key\_create(): 分配用于标识进程中线程特定数据的键 　　  
pthread\_setspecific(): 为指定线程特定数据键设置线程特定绑定 　　  
pthread\_getspecific(): 获取调用线程的键绑定，并将该绑定存储在 value 指向的位置中 　　  
pthread\_key\_delete(): 销毁现有线程特定数据键

## C语言多线程pthread库的相关函数说明 ##

**pthread\_t：**  
typedef unsigned long int pthread\_t;它是一个线程的标识符。

**pthread\_create：**  
函数pthread\_create用来创建一个线程，它的原型为：

extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,void *(*__start_routine) (void *)， void *__arg));
    
    int pthread_create((pthread_t*thread,pthread_attr_r*attr,void*(*start_routine)(void *),void *arg))

第一个参数为指向线程标识符的指针；  
第二个参数用来设置线程属性；  
attr: 线程属性包括：优先级、初始栈大小，是否应该成为一个守护线程。缺省设置，NULL.  
第三个参数是线程运行函数的起始地址；  
void *(* func) (void *)是一个函数指针，该函数指针的类型为void* (\*)(void \*)  
是一个参数为void \*，返回值也为void \*的函数类型。它的一个简单的例子如下

void *thread_handler(void *arg)
    { 
     return NULL;
    }

最后一个参数是运行函数的参数。  
void \*restrict arg  
arg是void *(* func) (void \*)函数指针的参数。

一般函数thread不需要参数，所以最后一个参数设为空指针。第二个参数也设为空指针，这样将生成默认属性的线程。对线程属性的设定和修改将在后续阐述。当创建线程成功时，函数返回0,若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINVAL.前者表示系统限制创建新的线程，例如线程数目过多了;后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。

**pthread\_join**  
函数pthread\_join用来等待一个线程的结束。函数原型为：

extern int pthread_join __P ((pthread_t __th, void **__thread_return));
    
    int pthread_join ((pthread_t th,void **thread_return))

第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了;另一种方式是通过函数pthread\_exit来实现。

缺省情况下，一个线程A的结束状态被保存下来直到pthread\_join为该线程被调用过，也就是说即使线程A已经结束，只要没有线程B调用 pthread\_join(A)，A的退出状态则一直被保存。而当线程处于Detached状态之时，党线程退出的时候，其资源可以立刻被回收，那么这个退出状态也丢失了。在这个状态下，无法为该线程调用pthread\_join函数。我们可以通过调用pthread\_detach函数来使指定线程进入 Detach状态：

int pthread_detach(pthread_t tid);

通过修改调用pthread\_create函数的attr参数，我们可以指定一个线程在创建之后立刻就进入Detached状态  
线程或者是可汇合的（joinable）或者是脱离的（detached）。当可汇合的线程终止时，其线程ID和退出状态将保留，直到另外一个线程调用pthread\_join。脱离的线程则像守护进程：当它终止时，所有的资源都释放，我们不能等待它终止。如果一个线程需要知道另一个线程什么时候终止，最好保留第二个线程的可汇合性。Pthread\_detach函数将指定的线程变为脱离的。该函数通常被想脱离自己的线程调用，如：pthread\_detach (pthread\_self ( ));

**pthread\_exit：**  
函数原型为：

extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
    
    Void pthread_exit(void *retval)

唯一的参数是函数的返回代码，只要pthread\_join中的第二个参数thread\_return不是NULL,这个值将被传递给 thread\_return.最后要说明的是，一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread\_join的线程则返回错误代码ESRCH.

**线程的退出:**

1.  在线程创建以后，就开始运行相关的线程函数，在该函数运行完之后，该线程也就退出了。这是线程退出的一种方法: 运行完毕，自动退出;
2.  调用pthread\_exit函数主动退出;
3.  进程终止函数exit函数，一旦结束了进程，那么此进程中所有线程都将无条件终止。

线程有三种退出方式  
1.线程从启动例程中返回(return方式)，返回值是现成的退出码  
2.线程被同一进程内的其他线程取消  
3.线程调用pthread\_exit退出。void pthread\_exit(void \*rval\_ptr)

**pthread\_cancel:**

int pthread_cancel(pthread_t thread);

让一个线程 能够请求另外一个线程结束，就像给它发送一个信号似的。用线程程是可以完成这一操作的，而与单处理经，线程在被要求结束执行的时候还有一种改变其行为的办法。

## 线程的一些常用属性以及如何设置这些属性 ##

**互斥锁相关：**  
互斥锁用来保证一段时间内只有一个线程在执行一段代码。  
**pthread\_mutex\_init：**  
函数pthread\_mutex\_init用来生成一个互斥锁。NULL参数表明使用默认属性。如果需要声明特定属性的互斥锁，须调用函数 pthread\_mutexattr\_init.函数pthread\_mutexattr\_setpshared和函数 pthread\_mutexattr\_settype用来设置互斥锁属性。前一个函数设置属性pshared,它有两个取值， PTHREAD\_PROCESS\_PRIVATE和PTHREAD\_PROCESS\_SHARED.前者用来不同进程中的线程同步，后者用于同步本进程的不同线程。在上面的例子中，我们使用的是默认属性PTHREAD\_PROCESS\_ PRIVATE.后者用来设置互斥锁类型，可选的类型有PTHREAD\_MUTEX\_NORMAL、PTHREAD\_MUTEX\_ERRORCHECK、 PTHREAD\_MUTEX\_RECURSIVE和PTHREAD \_MUTEX\_DEFAULT.它们分别定义了不同的上所、解锁机制，一般情况下，选用最后一个默认属性。

\*\* pthread\_mutex\_lock pthread\_mutex\_unlock pthread\_delay\_np\*\*  
pthread\_mutex\_lock声明开始用互斥锁上锁，此后的代码直至调用pthread\_mutex\_unlock为止，均被上锁，即同一时间只能被一个线程调用执行。当一个线程执行到pthread\_mutex\_lock处时，如果该锁此时被另一个线程使用，那此线程被阻塞，即程序将等待到另一个线程释放此互斥锁。

#define MAX 10
    pthread_t thread[2];
    pthread_mutex_t mut;
    int number=0, i;
    void *thread1()
    { 
    printf ("thread1 : I'm thread 1\n");
    for (i = 0; i < MAX; i++)
    { 
    printf("thread1 : number = %d\n",number);
    pthread_mutex_lock(&mut);
    number++;
    pthread_mutex_unlock(&mut);
    sleep(2);
    }
    printf("thread1 :主函数在等我完成任务\n");
    pthread_exit(NULL);
    }
    
    void *thread2()
    { 
    printf("thread2 : I'm thread 2\n");
    for (i = 0; i < MAX; i++)
    { 
    printf("thread2 : number = %d\n",number);[nextpage]
    pthread_mutex_lock(&mut);
    number++;
    pthread_mutex_unlock(&mut);
    sleep(3);
    }
    printf("thread2 :主函数在等我完成任务\n");
    pthread_exit(NULL);
    }
    
    void thread_create(void)
    { 
    int temp;
    memset(&thread, 0, sizeof(thread)); //comment1
    /*创建线程*/
    if((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0) //comment2
    printf("线程1创建失败!\n");
    else
    printf("线程1被创建\n");
    if((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0) //comment3
    printf("线程2创建失败");
    else
    printf("线程2被创建\n");
    }
    
    void thread_wait(void)
    { 
     /*等待线程结束*/
    if(thread[0] !=0) 
    {  //comment4
    pthread_join(thread[0],NULL);
    printf("线程1已经结束\n");
    }
    if(thread[1] !=0) 
    {  //comment5
    pthread_join(thread[1],NULL);
    printf("线程2已经结束\n");
    }
    }
    
    int main()
    { 
    /*用默认属性初始化互斥锁*/
    pthread_mutex_init(&mut,NULL);
    printf("我是主函数，我正在创建线程\n");
    thread_create();
    printf("我是主函数，我正在等待线程完成任务\n");
    thread_wait();
    return 0;
    }

一个简单的创建线程例子

#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;
    }

在编译的时候需要注意，由于线程创建函数在libpthread.so库中，所以在编译命令中需要将该库导入。命令如下：

gcc –o createthread –lpthread createthread.c

下面一个问题和前面创建进程类似，不过带来的问题回避进程要严重得多。如果你的主线程，也就是main函数执行的那个线程，在你其他县城推出之前就已经退出，那么带来的bug则不可估量。通过pthread\_join函数会让主线程阻塞，直到所有线程都已经退出。

int pthread_join(pthread_t thread, void **value_ptr);

thread：等待退出线程的线程号。  
value\_ptr：退出线程的返回值。  
结合上面的内容给出例子：

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;
    }

可以通过pthread\_join()函数来使主线程阻塞等待其他线程退出，这样主线程可以清理其他线程的环境。但是还有一些线程，更喜欢自己来清理退出的状态，他们也不愿意主线程调用pthread\_join来等待他们。我们将这一类线程的属性称为detached。如果我们在调用pthread\_create()函数的时候将属性设置为NULL，则表明我们希望所创建的线程采用默认的属性，也就是jionable。如果需要将属性设置为detached，则参考下面的例子：

#include <stdio.h>
    #include <pthread.h>
    void * start_run(void * arg)
    { 
            //do some work
    }
    int main()
    { 
            pthread_t thread_id;
            pthread_attr_t attr;
            pthread_attr_init(&attr);
            pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
            pthread_create(&thread_id,&attr,start_run,NULL);
            pthread_attr_destroy(&attr);
            sleep(5);
            exit(0);
    }

在线程设置为joinable后，可以调用pthread\_detach()使之成为detached。但是相反的操作则不可以。还有，如果线程已经调用pthread\_join()后，则再调用pthread\_detach()则不会有任何效果。