ACE-ACE线程管理机制

来源：互联网发布：windows安装器装win10 编辑：程序博客网时间：2024/05/16 00:42

ACE线程管理机制

ACE拥有许多不同的用于创建和管理多线程程序的类。在这里，我将简单的介绍一下ACE中的一些线程管理机制。

本节包含如下内容：

线程的创建与管理
线程间的并发控制
1. ACE Lock类属
2. ACE Guard类属
3. ACE Condition类属
4. ACE Synchronization类
面向对象的线程类ACE_Task

线程的创建与管理

有过在不同的操作系统下用c++进行过多线程编程的朋友对那些线程处理的API可能深有体会，这些API提供了相同或是相似的功能，但是它们的API的差别却极为悬殊，十分令人头痛。

ACE_Thread提供了对不同OS的线程调用的简单包装，通过一个通用的接口进行处理线程创建、挂起、取消和删除等问题。

一．线程入口函数

所有线程必须从一个指定的函数开始执行，该函数称为线程函数，它必须具有下列原型：
void* worker(void *arg) {}
该函数输入一个void *型的参数，可以在创建线程时传入。
注意：所有的线程启动函数（方法）必须是静态的或全局的（就如同直接使用OS线程API时所要求的一样）。

二．线程基本操作

1．创建一个线程

一个进程的主线程是由操作系统自动生成，如果你要让一个主线程创建额外的线程，可以通过ACE_Thread::spawn()实现，该函数一般的使用方式如下：

    ACE_thread_t threadId;
    ACE_hthread_t threadHandle;

    ACE_Thread::spawn(
        (ACE_THR_FUNC)worker,        //线程执行函数
        NULL,                        //执行函数参数
        THR_JOINABLE | THR_NEW_LWP,
        &threadId,
        &threadHandle
        );

为了简化，也可以使用其默认参数，直接使用ACE_Thread::spawn((ACE_THR_FUNC)worker) 来创建一个worker的线程。

另外，ACE还提供了ACE_Thread::spawn_n函数来创建多个线程。

2．终止线程

在线程函数体中ACE_Thread::exit()调用即可终止线程执行。

3．设定线程的相对优先级

当一个线程被首次创建时，它的优先级等同于它所属进程的优先级。一个线程的优先级是相对于其所属的进程的优先级而言的。可以通过调用ACE_Thread::setprio函数改变线程的相对优先级，该函数的调用方式如下：
ACE_Thread::setprio(threadHandle,ACE_DEFAULT_THREAD_PRIORITY)

4．挂起及恢复线程

挂起线程可以通过来实现，它能暂停一个线程的执行，其调用方式如下ACE_Thread::suspend(threadHandle) 。
相应的，可以通过ACE_Thread::resume(threadHandle) 恢复被挂起的线程的执行。

5．等待线程结束

在主函数中调用ACE_Thread::join(threadHandle)可阻塞主函数，直道线程结束才能继续执行。

6．停止线程

在主函数中调用ACE_Thread::cancel (threadHandle)可停止线程的执行（在Unix底下可以，而在windows下好像不起作用，有待检验）。

三．程序示例

下面例子演示了如何用ace创建一个线程。

#include "ace/Thread.h"
#include "ace/Synch.h"

#include <iostream>
using namespace std;

void* worker(void *arg)
{
    for(int i=0;i<10;i++)
    {
        ACE_OS::sleep(1);
        cout<<endl<<"hello world"<<endl;
    }
    return NULL;
}

int main(int argc, char *argv[])
{
    ACE_thread_t threadId;
    ACE_hthread_t threadHandle;

    ACE_Thread::spawn(
        (ACE_THR_FUNC)worker,        //线程执行函数
        NULL,                        //执行函数参数
        THR_JOINABLE | THR_NEW_LWP,
        &threadId,
        &threadHandle
        );

    ACE_Thread::join(threadHandle);

    return 0;
}

在这个简单的例子中，创建了1个工作者线程，执行程序中定义的worker()函数。然后阻塞主函数，待线程结束后退出程序。

线程间的并发控制

ACE有若干可用于并发控制的类。这些类可划分为以下范畴：

ACE Lock类属
ACE Guard类属
ACE Condition类属
ACE Synchronization类

ACE Lock类属

锁类属包含的类包装简单的锁定机制，比如互斥体、信号量、读／写互斥体和令牌等。这里我就以互斥体为例简单的介绍一下其使用方法，对其它的锁类进行一些简单的说明。

1．互斥体的使用。

互斥体用于保护共享的易变代码，也就是全局或静态数据。这样的数据必须通过互斥体进行保护，以防止它们在多个线程同时访问时损坏。

在ACE中可以通过ACE_Thread_Mutex实现线程的访问互斥，下面的例子演示ACE_Thread_Mutex类的使用。

#include "ace/Thread.h"
#include "ace/Synch.h"

#include <iostream>
using namespace std;

ACE_Thread_Mutex mutex;

void* Thread1(void *arg)
{
    mutex.acquire();
    ACE_OS::sleep(3);
    cout<<endl<<"hello thread1"<<endl;
    mutex.release();

    return NULL;
}

void* Thread2(void *arg)
{
    mutex.acquire();
    cout<<endl<<"hello thread2"<<endl;
    mutex.release();

    return NULL;
}

int main(int argc, char *argv[])
{
    ACE_Thread::spawn((ACE_THR_FUNC)Thread1);

    //Thread2 比Thread1晚创建1秒钟，故后尝试获取互斥体
    ACE_OS::sleep(1);
    ACE_Thread::spawn((ACE_THR_FUNC)Thread2);

    while(true)
        ACE_OS::sleep(10);

    return 0;
}

ACE_Thread_Mutex主要有两个方法：

acquire()：用来获取互斥体，如果无法获取，将阻塞至获取到为止。
release()：用来释放互斥体，从而使自己或者其它线程能够获取互斥体。

当线程要访问共享资源时，首先调用acquire()方法获取互斥体，从而获取对改互斥体所保护的共享资源的唯一访问权限，访问结束时调用释放互斥体，使得其它线程能获取共享资源的访问权限。

在此例中，本来Thread2的打印消息在Thread1之前，但由于Thread1先获得互斥体，故Thread2只有待Thread1结束后才能进入临界区。读者朋友们可以通过将ACE_Thread_Mutex替换为ACE_NULL_Mutex看一下不加锁的执行结果。

2．ACE Lock类属简介。

ACE Lock类属列表如下：

名字

描述

ACE_Mutex

封装互斥机制（根据平台，可以是mutex_t、pthread_mutex_t等等）的包装类，用于提供简单而有效的机制来使对共享资源的访问序列化。它与二元信号量（binary semaphore）的功能相类似。可被用于线程和进程间的互斥。

ACE_Thread_Mutex

可用于替换ACE_Mutex，专用于线程同步。

ACE_Process_Mutex

可用于替换ACE_Mutex，专用于进程同步。

ACE_NULL_Mutex

提供了ACE_Mutex接口的"无为"（do-nothing）实现，可在不需要同步时用作替换。

ACE_RW_Mutex

封装读者／作者锁的包装类。它们是分别为读和写进行获取的锁，在没有作者在写的时候，多个读者可以同时进行读取。

ACE_RW_Thread_Mutex

可用于替换ACE_RW_Mutex，专用于线程同步。

ACE_RW_Process_Mutex

可用于替换ACE_RW_Mutex，专用于进程同步。

ACE_Semaphore

这些类实现计数信号量，在有固定数量的线程可以同时访问一个资源时很有用。在OS不提供这种同步机制的情况下，可通过互斥体来进行模拟。

ACE_Thread_Semaphore

应被用于替换ACE_Semaphore，专用于线程同步。

ACE_Process_Semaphore

应被用于替换ACE_Semaphore，专用于进程同步。

ACE_Token

提供"递归互斥体"（recursive mutex），也就是，当前持有某令牌的线程可以多次重新获取它，而不会阻塞。而且，当令牌被释放时，它确保下一个正阻塞并等待此令牌的线程就是下一个被放行的线程。

ACE_Null_Token

令牌接口的"无为"（do-nothing）实现，在你知道不会出现多个线程时使用。

ACE_Lock

定义锁定接口的接口类。一个纯虚类，如果使用的话，必须承受虚函数调用开销。

ACE_Lock_Adapter

基于模板的适配器，允许将前面提到的任意一种锁定机制适配到ACE_Lock接口。

可以简单的分为以下几类：

互斥锁
互斥锁（通常称为"互斥体"或"二元信号量"）用于保护多线程控制并发访问的共享资源的完整性。互斥体通过定义临界区来序列化多线程控制的执行，在临界区中每一时刻只有一个线程在执行它的代码。互斥体简单而高效（时间和空间）。
ACE线程库提供了Mutex式的类（是一组互斥体对象，拥有类似的接口），他是一种简单而高效的类型是"非递归"互斥体。非递归互斥体不允许当前拥有互斥体的线程在释放它之前重新获取它。否则，将会立即发生死锁。递归互斥体在ACE Recursive_Thread_Mutex类中可移植地实现。
读者/作者锁
读者/作者锁与互斥体相类似。例如，获取读者/作者锁的线程也必须释放它。多个线程可同时获取一个读者/作者锁用于读，但只有一个线程可以获取该锁用于写。当互斥体保护的资源用于读远比用于写要频繁时，读者/作者互斥体有助于改善并发的执行。
ACE线程库提供了一个叫作RW_Mutex的类，在C++封装类中可移植地实现了读者/作者锁的语义。读者/作者锁将优先选择权给作者。因而，如果有多个读者和一个作者在锁上等待，作者将会首先获取它。

计数信号量
在概念上，计数信号量是可以原子地增减的整数。如果线程试图减少一个值为零的信号量的值，它就会阻塞，直到另一个线程增加该信号量的值。
计数信号量用于追踪共享程序状态的变化。它们记录某种特定事件的发生。因为信号量维护状态，它们允许线程根据该状态来作决定，即使事件是发生在过去。
信号量比互斥体效率要低，但是，它们要更为通用，因为它们无需被最初获取它们的同一线程获取和释放。这使得它们能够用于异步的执行上下文中（比如信号处理器）。ACE线程库提供一个叫作Semaphore的类来可移植地在C++包装类中实现信号量语义。

ACE Guard类属

与C一级的互斥体API相比较，Mutex包装为同步多线程控制提供了一种优雅的接口。但是，Mutex潜在地容易出错，因为程序员有可能忘记调用release方法（当然，C级的互斥体API更容易出错）。这可能由于程序员的疏忽或是C++异常的发生而发生，然而，其导致及其严重的后果--死锁。

因此，为改善应用的健壮性，ACE同步机制有效地利用C++类构造器和析构器的语义来确保Mutex锁被自动获取和释放。

ACE提供了一个称为Guard、Write_Guard和Read_Guard的类族，确保在进入和退出C++代码块时分别自动获取和释放锁。

Guard类是最基本的守卫机制，定义可以简化如下（实际定义比这相对要复杂而完善一点）：

template <class LOCK>
class Guard
{
public:
    Guard (LOCK &l): lock_ (&l){ lock_.acquire (); }

    ˜Guard (void) {    lock_.release (); }
private:
    LOCK lock_;
}

Guard类的对象定义一"块"代码，在其上锁被自动获取，并在退出块时自动释放，即使是程序抛异常也能保证自动解锁。这种机制也能为Mutex、RW_Mutex和Semaphore同步封装工作。

对于读写锁，由于加锁接口不一样，ace也提供了相应的Read_Guard和Write_Guard类，Read_Guard和Write_Guard类有着与Guard类相同的接口。但是，它们的acquire方法分别对锁进行读和写。

缺省地， Guard类构造器将会阻塞程序，直到锁被获取。会有这样的情况，程序必须使用非阻塞的acquire调用（例如，防止死锁）。因此，可以传给ACE Guard的构造器第二个参数（请参看原始代码，而不是我这里的简化代码），指示它使用锁的try_acquire方法，而不是acquire。随后调用者可以使用Guard的locked方法来原子地测试实际上锁是否已被获取。

用Guard重写上一节的Thread1方法如下（注释了的部分是原有代码）：

void* Thread1(void *arg)
{
    ACE_Guard<ACE_Thread_Mutex> guard(mutex);
    //mutex.acquire();
    ACE_OS::sleep(3);
    cout<<endl<<"hello thread1"<<endl;
    //mutex.release();

    return NULL;
}

相比较而言，使用Guard更加简洁，并且会自动解锁，免除了一部分后顾之忧。

注意：

Guard只能帮你自动加解锁，并不能解决死锁问题，特别是对于那些非递归的互斥体来说使用Guard尤其要注意防止死锁。

Guard是在Guard变量析构时解锁，如果在同一函数中两次对同一互斥体变量使用Guard要注意其对象生命周期，否则容易造成死锁。

ACE Condition类属

ACE Condition类属（条件变量）提供风格与互斥体、读者/作者锁和计数信号量不同的锁定机制。当持有锁的线程在临界区执行代码时，这三种机制让协作线程进行等待。相反，条件变量通常被一个线程用于使自己等待，直到一个涉及共享数据的条件表达式到达特定的状态。当另外的协作线程指示共享数据的状态已发生变化，调度器就唤醒一个在该条件变量上挂起的线程。于是新唤醒的线程重新对它的条件表达式进行求值，如果共享数据已到达合适状态，就恢复处理。

ACE线程库提供一个叫作Condition的类来可移植地在C++包装类中实现条件变量语义。定义方式如下：
ACE_Thread_Mutex mutex;
ACE_Condition<ACE_Thread_Mutex> cond(mutex);

该对象有两个常用方法。

signal()
向使用该条件变量的其它线程发送满足条件信号。
wait()
查询是否满足条件，如果满足，则继续往下执行；如果不满足条件，主线程就等待在此条件变量上。条件变量随即自动释放互斥体，并使主线程进入睡眠。

条件变量总是与互斥体一起使用。这是一种可如下描述的一般模式：

while( expression NOT TRUE ) wait on condition variable;

条件变量不是用于互斥，往往用于线程间的协作，下面例子演示了通过条件变量实现线程协作。

#include "ace/Thread.h"
#include "ace/Synch.h"

#include <iostream>
using namespace std;

ACE_Thread_Mutex mutex;
ACE_Condition<ACE_Thread_Mutex> cond(mutex);

void* worker(void *arg)
{
    ACE_OS::sleep(2);        //保证eater线程的cond.wait()在worker线程的cond.signal()先执行
    mutex.acquire();
    ACE_OS::sleep(1);
    cout<<endl<<"produce"<<endl;
    cond.signal();
    mutex.release();
    return NULL;
}

void* eater(void *arg)
{
    mutex.acquire();
    cond.wait();
    cout<<endl<<"eat"<<endl;
    mutex.release();
    return NULL;
}

int main(int argc, char *argv[])
{
    ACE_Thread::spawn((ACE_THR_FUNC)worker);
    ACE_OS::sleep(1);
    ACE_Thread::spawn((ACE_THR_FUNC)eater);

    while(true)
        ACE_OS::sleep(10);

    return 0;
}

这个例子中，首先创建了一个生产者线程worker和一个消费者线程eater，消费者线程执行比生产者快，两个线程不加限制并发执行会导致先消费，后生产的情况（只是加互斥锁也不能很好的解决，以为无法保证生产者一定先获得互斥体）。所以这里通过条件变量的通知方式保证线程的顺序执行：

消费者线程获取互斥体，等待条件满足（生产者生产了食品）。同时释放互斥体，进入休眠状态。
生产者获取互斥体（虽然是消费者先获取的互斥体，但消费者调用的wait函数会释放消费者的互斥体），生产商品后，通过条件变量发送信号（调用signal函数）通知消费者生产完成，结束生产过程，释放互斥体。
消费者收到信号后，重新获取互斥体，完成消费过程。

使用条件变量的注意事项：

条件变量必须和互斥体一起使用，也就是说使用前必须加锁（调用互斥体acquire函数），使用完后需释放互斥体。

条件变量中的wait()和signal()成对使用的话，必须保证wait()函数在signal()之前执行，这样才能保证wait()能收到条件满足通知，不至于一直等待下去，形成死锁（worker线程中的第一句话就是起的这个作用）。

ACE Synchronization类

这一类并发控制对象一般也叫做杂项并发类，这类对象一般用得不多，这里我只是对其作一些简单的介绍。

1．Atomic_Op类

ACE_Atomic_Op类用于将同步透明地参数化进基本的算术运算中。

ACE_Atomic_Op是一种模板类，锁定机制和需要参数化的类型被作为参数传入其中，重载所有算术操作符，并确保在操作前获取锁，在操作后释放它。运算本身被委托给通过模板传入的的类。

使用ACE_Atomic_Op进行变量封装时，对于那些用ACE_Atomic_Op封装了的变量操作都变成了线程安全的，而并看不到显式的加解锁代码，代码变得更简洁，优雅。

2．ACE中的栅栏（Barrier）

一组线程可以使用栅栏来进行共同的相互同步。组中的每个线程各自执行，直到到达栅栏，就阻塞在那里。在所有相关线程到达栅栏后，它们就全部继续它们的执行。就是说，它们一个接一个地阻塞，等待其他的线程到达栅栏；一旦所有线程都到达了它们的执行路径中的"栅栏点"，它们就一起重新启动。

在ACE中，栅栏在ACE_Barrier类中实现。在栅栏对象被实例化时，它将要等待的线程的数目会作为参数传入。一旦到达执行路径中的"栅栏点"，每个线程都在栅栏对象上发出wait()调用。它们在这里阻塞，直到其他线程到达它们各自的"栅栏点"，然后再一起继续执行。当栅栏从相关线程那里接收了适当数目的wait()调用时，它就同时唤醒所有阻塞的线程。

举个简单的例子，运动员进行赛跑比赛时，虽然他们到达终点有先后顺序，但会等到所有的运动员跑完比赛后才一起领奖。

面向对象的线程类ACE_Task

我们在前一章中使用ACE_Thread包装时，你一定已经注意到了一些不够"优雅"的地方。那一章中的大多数程序都被分解为函数、而不是对象。这是因为ACE_Thread包装需要一个全局函数名、或是静态方法作为参数。随后该函数（静态方法）就被用作所派生的线程的"启动点"。这自然就使得程序员要为每个线程写一个函数。如我们已经看到的，这可能会导致非面向对象的程序分解。

ACE_Task对常用线程处理进行了OO包装，通过ACE_Task，能对线程进行更好的操作。

要创建任务，需要进行以下步骤：

实现服务初始化和终止方法：
open()方法应该包含所有专属于任务的初始化代码。其中可能包括诸如连接控制块、锁和内存这样的资源。close()方法是相应的终止方法。
调用启用（Activation）方法：
在主动对象实例化后，你必须通过调用activate()启用它。要在主动对象中创建的线程的数目，以及其他一些参数，被传递给activate()方法。activate()方法会使svc()方法成为所有它生成的线程的启动点。
实现服务专有的处理方法：
如上面所提到的，在主动对象被启用后，各个新线程在svc()方法中启动。应用开发者必须在子类中定义此方法。

下面的例子演示怎样去创建任务：

#include "ace/Task.h"
#include "ace/OS.h"

#include <iostream>
using namespace std;

class TaskThread: public ACE_Task<ACE_MT_SYNCH>
{
public:
    virtual int svc(void)
    {
        for(int i=0;i<10;i++)
        {
            ACE_OS::sleep(1);
            cout<<endl<<"hello thread1"<<endl;
        }
        return 0;
    }
};

int main(int argc, char *argv[])
{
    TaskThread task;
    task.activate();

    while(true)
        ACE_OS::sleep(10);

    return 0;
}

ACE_Task也封装了常用线程操作，如暂停，恢复及停止等，是不是非常简单和方便呢。

其实ACE_Task的使用还不仅仅是这些，通过它还可实现一种很常用的网络编程模式－－主动对象模式，其具体功能在后续的设计模式部分将作详细的介绍。

引用：http://www.cnblogs.com/TianFang/archive/2006/12/04/581293.html