欧美岛国在线观看,亚洲毛片在线观看,国产精品久久影院

Linux操作�pȝ��中中断上下文中的互斥

martin_yahoo — Mon, 08 Jul 2013 06:01:00 GMT

在Linux�pȝ��中，有两�U�不同的上下文：�q�程上下文、中断上下文�?br />在中断中没有�q�程上下文，而具有中断上下文�Q�因此在中断上下文中不能发生睡眠�Q�也��是不能发生�q�程切换�?br />�q�就军_��了在在中断上下文中不能采用同步原语（信号量，��程、同步变量等�Q�和长期互斥原语�Q�这会导致进�E�睡眠）�Q?而只能采用短期互斥原语（例如自旋锁）�?br />
曄��Q�中断处理程序�ƈ不具有自��q��栈。相反，它们�׃�n所中断�q�程的内核栈。内核栈的大��是两页�Q�具体地��_��?2位体�pȝ��构上�?KB,�?4位体�pȝ��构上�?6KB.
现在。中断处理程序有了自��q��栈，每个处理器一个，大小��Z��c��这个栈��q��Z��断栈�Q�尽��中断栈的大��是原先�׃�n栈的一半，但��^均可用栈�I�间大得多，因�ؓ中断处理
�E�序把这一整页占�ؓ己有�?br />

UP�Q�单CPU�pȝ��)上的中断处理
互斥
如果一个中断处理程序的代码讉K��或者更��C��由非中断的代码（通常�U�Cؓ基准代码�Q��用的同一数据�l�构�Q�那么就会出现竞争条件�?br />�q�运的是�Q�得到允许的以内核态执行的�q�程会��时禁止中断。因此，只要基准代码要更��C��个与中断处理�E�序�׃�n的数据结构，那么��?br />首先��止中断�Q�执行��界段�Q�然后再重新允许中断。禁止和允许中断的动作就实现了互斥�?br />在采取中断互斥时�Q�必��M��用函数显�C�地把编码写入算法中�?br />
MP�Q�多CPU�pȝ��Q�上
在MP�pȝ��上，中断可以在�Q何处理器上出现。从最低限度上来说�Q�每个进�E�会接收旉��中断�Q�但也可能接收I/O中断。在MP�pȝ��上，例程
SPL�Q�禁止中断）所提供的保护�ƈ不充分，因�ؓ它们执行影响执行它们的处理器上的中断优先�U�。中断可能会在另一个处理器上出玎ͼ�如果讑֤�驱动�E�序
正在别处�q�行�Q�那么会造成一个竞争条件。因��Z��断处理程序代表另一个进入内核的入口炏V�?br />
当基准驱动程序代码和中断处理�E�序之间�׃�n数据�l�构�Ӟ��UP可以通过屏蔽中断来防止出现竞争条件的技术，在多�U�程MP内核中还不充分�?br />临界�D�要在一个处理器上执行，执行屏蔽中断例程只会屏蔽在那个处理器上出现的中断。如果在别的处理器上出现中断�Q�那么立卛_��会有
两个处理器同时访问、而且可能更新临界资源。既然这些��界段需要短期互斥，那么可以使用自旋锁来�Ҏ��据进行保护�?br />
如果不考虑中断处理�E�序和基准代码之间的互斥�Q�则Linux中的中断处理�E�序是无��重入的。当一个给定的中断处理�E�序正在执行�Ӟ��相应的中断线
在所有处理器上都会被屏蔽掉，以防止同一中断�U�上接收另一个新的中断。通常情况下，所有的其他中断都是打开的，所以这些不同中断线上的其他中断
都能处理�Q�但当前中断�U��L��被禁止的。由此可以看出，同一个中断处理程序绝不会被同时调用以处理嵌套的中断。这极大地简化了中断�E�序的编写�?/div>

martin_yahoo 2013-07-08 14:01 发表评论

martin_yahoo — Thu, 20 Jun 2013 07:02:00 GMT

MP(多CPU�Q�同步原语代码示�?br />                   ----引自《现代体�pȝ��构上的UNIX�pȝ��?br />
��Z��便于对示例的展开�Q�我们首先假定一个场景：
内核中把��到的错误信息记录到一个磁盘文件中的情形。出错信息通过内存中的一个队列来传递给日志�q�程�Q�logging process)的�?br />当出��C��个错误时�Q�就在队列中加入一��，�q�且通过调用函数log_error 通知日志�q�程。出错日志进�E�接着把队列中的项写到��盘上�?br />�q�就使得��到错误的进�E�不必等候I/O完成或者或得�ؓ了向文�g执行I/O而可能需要的��M��锁，�q�且避免了�Q何可能的上锁�ơ序问题�?br />
代码1�Q?采用事�g计数的出错日志通知机制

                                               日志�q�程
log_error(error)                    |
{                                         |       for(next=1; ; next++) {
   lock(&err_queue);             |           await(&err_event, next);
   把出错信息加入到队列           |          lock(&err_queue);
   unlock(&err_queue);          |          从队列中删除��?br />   advance(&err_event);        |          unlock(&err_queue);
}                                         |          write error to disk
                                           |       }

队列本��n�׃��个自旋锁来保护。在本例中，事�g计数只用于同步的目的�Q��ƈ不提供互斥�?br />在试用事件计数的时候，advance操作会永久性地改变事�g计数的状态。advance和await操作的相�Ҏ��序没有关�p�R�?br />
代码2�Q?采用同步变量的出错日志通知机制
                                                 日志�q�程
log_error(error)                            |
{                                                 |        for(;;){
   lock(&err_queue);                      |              lock(&err_queue);
   把出错信息加入到队列                    |              if (queue_empty){
   SV_SIGNAL(&err_syncvar, 0);      |                  SV_WAIT(&err_syncvar, PRI, &err_queue);
   unlock(&err_queue);                   |                  lock(&err_queue);
}                                                 |              }
                                                   |              从队列中删除��?br />                                                   |              unlock(&err_queue);
                                                   |              把错误写入磁�?br />                                                   |        }

因�ؓ同步变量自��n没有保留状态，所以当日志�q�程��试队列的状态�ƈ军_��是等待一��还是从队列中删除一��的时候，必须占有自旋锁。类似地�Q�log_error�?br />发送信��h��也必��d��有自旋锁。注�Q�SV_WAIT��释放自旋锁�Q��ƈ且阻塞日志进�E?SV_SIGNAL到后从阻塞处�l�箋执行�?br />
代码3�Q?采用��程的出错日志通知机制
                                                                 日志�q�程
log_error(error)                                  |       for(;;){
{                                                       |           mon_enter(&err_mon);
   mon_enter(&err_mon);                     |           if (queue empty)
   把出错信息加入到队列                          |               mon_wait(&err_mon, NEWENTRY);
                                                         |
   mon_signal(&err_mon, NEWENTRY); |           从队列中删除��?br />   mon_exit(&err_mon);                       |           mon_exit(&err_mon);
}                                                       |           把错误写入磁�?br />                                                         |       }

代码4�Q?采用信号量的出错日志通知机制
                                                日志�q�程
log_error(error)                      |       for(;;){
{                                          |           P(&err_sema);
    lock(&err_queue);               |           lock(&err_queue);
   把出错信息加入到队列            |           从队列中删除��?br />   unlock(err_queue);              |           unlock(&err_queue);
   V(&err_sema);                   |           把错误写入磁�?br />}                                          |       }

martin_yahoo 2013-06-20 15:02 发表评论

unix �cȝ��l�中的进�E�同步方式�ȝ��

martin_yahoo — Thu, 20 Jun 2013 05:49:00 GMT

我们把异步环境下的一�l��ƈ发进�E�因直接制约而互相发送消息、进行互相合作、互相等待，使得各进�E�按一定的速度执行的过�E�称��E�间的同步�?br />��h��同步关系的一�l��ƈ发进�E�称为合作进�E�，合作�q�程间互相发送的信号�U�Cؓ消息或事件�?如果我们对一个消息或事�g赋以唯一的消息名�Q�则我们
可用�q�程　wait (消息�?　表示�q�程�{�待合作�q�程发来的消息，而用�q�程　signal (消息�? 表示向合作进�E�发送消息�?br />(引自癑ֺ�癄��Q?br />
�q�程间的同步方式�Q?br />��Z��实现�q�程互斥地进入自��q��临界区，操作�pȝ��中设�|�专门的同步机制来协调各�q�程间的�q�行。所有的同步机制都应遵��@下书四条准则�Q?br />1�Q�空闲让�q?br />2�Q�忙则等�?br />3�Q�有限等�?br />4�Q�让权原则。当�q�程不能�q�入自己的��界区�Ӟ��应立即释攑֤�理机�Q�以免进�E�陷�?#8220;忙等”状态�?br />
1.单CPU (UP)机器利用sleep/wakeup函数对实现同步机制�?br />函数sleep是一个内部的内核例程�Q�它挂�v调用它的�q�程�Q�直到指定的事�g发生为止。这是一个以内核态运行的�q�程自愿��控制权，允许自己被抢占�?br />函数wakeup用于发出一个特定事件已�l�出现的信号�Q�它使得所有等待该事�g的进�E�被唤醒�Q��ƈ攑֛�到运行队列中。事件用一个整数值来表示�Q�它往往
是该事�g相关的内核数据结构的地址�?br />
void lock_object( char *flag_ptr)
{
    lock(&object_locking);       //自旋�?br />     while (*flag_ptr)
           sleep(flag_ptr);
     *flag_ptr = 1;
   unlock(&object_locking);
}

void unlock_object( char *flag_ptr)
{
    lock( &object_locking );
    *flag_ptr = 0;
    wakeup( flag_ptr);
   unlock( &object_locking );
}

应�ؓwakeup操作没有记忆�Q�所以wakeup函数必须唤醒在同一事�g上睡眠的所有进�E�。在多CPU�pȝ��上，即MP上sleep/wakeup机制不�v作用�?br />
2.SVR4.2 MP 提供了单独的执行�q�程同步的原语：同步变量�?br />因�ؓ同步变量不包含状态，所以可以把它们��x��是sleep/wakeup的一�U�MP变�Ş。相反，所需的�Q何状态信息都保存在外部标志或者计数器中�?br />同步变量的设计要同自旋锁配合工作�?br />
同步变量被声明�ؓsv_t�c�d��Q�采用下面的函数可以�l�它分配�I�间和进行初始化�Q?br />sv_t *SV_ALLOC( int slpflag);
slpflag指定�Q�如果需要�ؓ同步变量分配内存�Q�那么是否能��d��q�程�?br />
回收同步变量可以调用
void SV_DEALLOC( sv_t *svp );

内核希望单独�{�候的每一个事仉��用一个不同的同步变量来表�C�，�q�就好比配合sleep如何使用唯一的事件参数�?br />void SV_WAIT( sv_t *svp, int pri, lock_t *lockp );

要触发在同步变量上的事�g�Q�可以��用下面的函数�Q?br />void SV_SIGNAL( sv_t *svp, int flags);
SV_SIGNAL与wakeup的相��g��处在于，如果没有正在睡眠的进�E�，那么��对�q�去曄��执行�q�的操作没有记忆�Q�调用什么也不做�?br />SV_SIGNAL只唤醒一个进�E�。如果要唤醒在事件上睡眠的所有进�E�，可以用同步变量的下列函数来实玎ͼ�
void SV_BROADCAST( sv_t *svp, int flags);

如果在事件被触发之前出现了一个UNIX信号�Q�那么下面的SV_WAIT变�Ş会唤醒进�E�：
bool_t SV_WAIT_SIG( sv_t *svp, int pri, lock_t *lkp );
�q�回的代码表明发生了什么样的事�Ӟ��如果出现了一个UNIX信号�Q�那么它�q�回FALSE,如果出现了SV_SIGNAL或SV_BROADCAST,那么它返回TRUE.

3.采用信号量的同步
��信号量的值初始化�?,��可以用于进�E�同步，�q�样允许通过使用P操作让一个进�E�等待某个事件发生。既然信号量被初始化�?�Q�那么进�E�将立即��d��?br />另一个进�E��用V操作能够发出信号�Q�表明事件已�l�结束。V操作��D��正等待事件的�q�程被唤醒，�q��l�进行。因为即使在信号量上没有��d��q�程�Q?br />V操作也会�l�信号量�?�Q�所以在前一个进�E�能够执行P操作之前出发事�g会导致进�E��l�进行，不必�{�待。这是一�U�受�Ƣ迎的情形，因�ؓ它不需要额外的
协调工作�Q�就能够处理在等候事件的�q�程同发信号表明该事件完成的�q�程之间本来��有的竞争条件�?br />
�q�程1                                        �q�程2
p(s)       /*�{�待事�g*/                    .
                                                  .
                                                  .
                                                V(s) /*触发事�g*/

4.利用��程�q�行同步
��程��Z��界资源以及访问或者修改该资源的所有��界段提供了互斥机�Ӟ��它还提供了在使用��程的诸�q�程之间�q�行同步的手�D�c��一个管�E�可以想成是一个装�?br />资源的隔间。进�E�要讉K��资源�Q�它必须首先�q�入隔间。通过一�ơ只允许一个进�E�进入隔��_��做��C��互斥。如果在��程已经投入使用的时候，别的�q�程试图�q?br />入它�Q�那��׃��被阻塞，直到使用��程的进�E�退出管�E��ؓ止，或者在与管�E�关联的事�g上等待。每个管�E�都可能有一个或者更多的事�g�Q�若�q�进�E�能够在�q�些�?br />件上�{�待。进�E�被��d��q�些事�g上，直到在管�E�内执行的其他进�E�触发事件�ؓ止。根据定义，触发操作只能从管�E�内部完成�?br />

5.利用事�g计数�q�行同步
事�g计数是一个非递减的正整数�Q�在�q�个数��g��定义�?�U�操作。操作advance(E)��事件计数E�?,�q�叫做出发事件�?br />操作await(E,V)致��调用�q�程被阻塞，指导事�g计数E的��D��到V为止。如果在调用await的时候，事�g计数的值大于或�{�于V�Q�那么进�E��l�执行，而不会阻塞，
因�ؓ事�g是以前触发的。事件计数的当前值可以用read(E)来读取。在创徏事�g计数的时候，它被初始化�ؓ0�Q�而且在数��g��永远不会减少。假定保存事件计数�?br />得存储器位置��_��大，于是事�g计数在其整个生命期中�Q�一直都不会溢出�Q�通常一�?2位的无符��h��数就够了�Q��?br />
有关代码�C�Z��Q�请参见后面的随�W��?img src ="http://www.shnenglu.com/martin/aggbug/201174.html" width = "1" height = "1" />

martin_yahoo 2013-06-20 13:49 发表评论

martin_yahoo — Sat, 08 Jun 2013 09:04:00 GMT

在多CPU�pȝ��Q�即MP�pȝ��中，存在�ȝ��仲裁�?br />
1. 原子操作
从CPU或者I/O讑֤��C��存储器的单次��L��者写操作为原子操作�?br />�q�样的操作一旦开始，��׃��能被�pȝ��上来自CPU或者I/O讑֤�的�Q何其他存储操作所中断�Q�或者受��C��们的�q�扰�?br />
原子变量

2. 自旋�?�Q�自旋锁用于短期互斥�Q?br />自旋锁得名于�q�样一个事实，一个进�E�在�{�候另一个进�E�正在��用的锁时会处于忙�{�待�Q�busy-wait,在一个��@环中自旋�Q�状态�?br />typedef int lock_t;
void initlock( volatile lock_t * lock_status)
{
   *lock_status = 0;
}

int
test_and_set(volatile int *addr)
{
   int old_value;
   old_value = swap_atomic(addr, 1);
   if (old_value == 0)
return 0;
   return 1;
}

void lock(volatile lock_t *lock_status)
{
    while (test_and_set( lock_status) == 1)            //被锁定时�Q�进�E�在此自旋�?br />       ;
}
// test_and_set 如果前面的状态不�?��p��?�Q�否则返�?.
//如果锁的状态已�l�是1�Q�锁已经被占用）�Q�那么test_and_set函数�q�回1�Q��ƈ且处理器在��@环中自旋�Q�直到该锁被释放为止。只要把锁的状态设�|��ؓ0�Q�就可以释放锁了�?br />
void
unlock(volatile lock_t * lock_status)
{
   *lock_status =0;
}

减少寚w��的争用可以采用两�U�办法：
�W�一、内栔R��对不同的临界资源使用不同的自旋锁�Q�防止处理器在没有竞争条件威胁的时候被另一个处理器挂�v�?br />�W�二、增强lock和unlock函数�Q�在上锁的时候屏蔽中断�?img src ="http://www.shnenglu.com/martin/aggbug/200878.html" width = "1" height = "1" />

martin_yahoo 2013-06-08 17:04 发表评论

martin_yahoo — Sat, 08 Jun 2013 06:54:00 GMT

在��^时的应用设计中，�׃��出现多线�E�（�q�程�Q�的�q�发应用�Q�以及分布式应用�Q�比较容易出现死锁现象�?br />
下面来看一个简单的实例�Q?br />有两个独立的链表�Q�假定��用两个独立的锁来保护他们�Q�以便能够独立的讉K��。再假定某个操作要求遍历一个列表所��索到的元素必��M��两个列表中断开�q�接�Q?br />而且必须以一��?span style="color: red;">原子操作来完成�?br />
�U�程1                                                   |           �U�程2
lock(&lock_a);                                    |    lock(&lock_b);
find element to unlink on list a               |        find element to unlink on list b
lock(&lock_b);                                      |       lock(&lock_a);
unlink element from both lists                |        unlink element from both lists
unlock(&lock_b);                                   |       unlock(&lock_a);
unlock(&lock_a);                                   |       unlock(&lock_b);

可能出现死锁的情��c�?br />�q�要求在消除一个元素是必须同时拥有两个列表的锁。对�W�一个线�E�要先或得锁lock_a, 然后要或得锁lock_b.
�W?个线�E�正好相反，它先或得锁lock_b,然后再获取锁lock_a.
如果某一时刻�Q�第一个线�E�执行到�?find element to unlink on list a, 而第二个�U�程此时执行��C��find element to unlink on list b, 则这两个�U�程��发生死锁�?br />�q�种死锁�U�CؓAB-BA死锁�?nbsp; �Q�注�Q�死锁的发生是跟两个�U�程的执行时序相关的�Q�例如，�W�一个线�E�执行完了所有的�q�部分代码，�U�程2才开始执行此�D�代码，则不会发生死锁。）

如果某个锁不是递归锁，例如lock_a, 而线�E?在应用中对它�q�行多个调用�Q�而没有调用解锁操作，也会发生死锁�?br />代码�C�Z��如下�Q?br />lock(&lock_a);
other logic code
lock(&lock_a);
other logic code
unlock(&lock_a);
unlock(&lock_a);

防止死锁的办�? ��Z��防止发生�q�类死锁�Q�所有线�E�必��M��相同的次序获得嵌套锁�Q�即以相同的�ơ序获得且同时占有锁�?br />可以把上面的代码�Ҏ��如下代码来避免死锁：
lock(&lock_a);
lock(&lock_b);
find element to unlink on list a or b
unlink element from both lists
unlock(&lock_b);
unlock(&lock_a);

当涉及到3个或者更多锁的时候也是如此：只要各线�E�在获得和释��N��的时候保持相同的�ơ序�Q�那么就不会出现死锁�?br />

martin_yahoo 2013-06-08 14:54 发表评论

martin_yahoo — Fri, 20 Mar 2009 03:41:00 GMT

实体�Q�语�a�内徏的数据类型，开发者定义的�c�d��Ҏ��{�）的定义与声明�Q�实体和指针跟程序设计带来了不同影响�Q?br>对于实体或定义，�~�译器要知道实体真实的物理内存布局�Q�因此让�~�译器知道这些信息，�q�且在程序编译完毕后不能更改�Q�要��x��改必��重新编译程序．因此如果在系�l�设计者程序库中运用了inline函数�Q��ƈ且如果应用开发者在应用中用了这个inline函数�Q�则当后来要对inline�q�行修改�Ӟ��有可能要��D��应用被重新编译．
对于指针�Q�它的大��在特定的机器上是固定的�Q�在32位机器上�Q�它的大��是32位；�?4位机器上�Q�它的大��是64位）�Q�因此可以改变它的��|��而不需要重新编译应用，��可以改变应用的功能�Q?br>
在面向对象中�Q�可以通过虚函数指针来延迟特定函数的决�{�，卌��用子�cȝ��函数�Q?br>在C语言中，我们可以通过函数指针来对函数的功能进行推�q�决�{�．
在C++中，我们也可以通过函数指针�Q�函数对象）、对象指针来推迟决策�Q�从而�ɽE�序的功能更有弹性。例如，在设计模式中的strategy模式中，��是通过在contex中包含一个指向strategy的指针来实现的。我们可以定义一个抽象的strategy接口�Q�然后由各个具体的strategy实现�q�些接口�Q�从而在保证应用架构几乎不做��M��调整下，实现不同的功能。当然在�q�种实现方式中，我们应该加入strategy的决议者，由它来裁决采用哪一�U�策略方式。决议者可以采用配�|�文件、应用的输入�{�作为决议的依据�?br>
熟悉symbian的�h�Q�很快就会发玎ͼ�它与symbian中的ECOM架构很相伹{��它要求各种strategy的实现方式被包含在共享的DLL中，�q�由RLibrary::Loard()调用动态蝲�?
使用定义抽象接口�Q�然后在各DLL中定义具体的实现�Q��ƈ且动态蝲入，我们可以比较�Ҏ��地实现所谓的插�g(plugin)。插件的载入取决于配�|�，或相应的输入��?br>
下面�l�出在linux和windows上从动态库中查扑֒�载入的例�?
#ifdef WIN32
        HINSTANCE hDll;
        if(!(hDll = LoadLibrary(VOCALSIP_DLLPATH)))
        adapter.m_initFunc = (INIT_PROTOSTACK_FUNC)GetProcAddress( hDll, "InitVocalSipStack");
        adapter.m_createFunc = (CREATE_CHANNEL_FUNC)GetProcAddress( hDll, "CreateVocalSipGCChannel");
        adapter.m_cleanupFunc = (CLEANUP_PROTOSTACK_FUNC)GetProcAddress( hDll, "CleanupVocalSipStack");
#else
        void* h_dl = dlopen(VOCALSIP_DLLPATH,RTLD_NOW | RTLD_GLOBAL);
        adapter.m_initFunc = (INIT_PROTOSTACK_FUNC)dlsym( h_dl, "InitVocalSipStack");
        adapter.m_createFunc = (CREATE_CHANNEL_FUNC)dlsym( h_dl, "CreateVocalSipGCChannel");
        adapter.m_cleanupFunc = (CLEANUP_PROTOSTACK_FUNC)dlsym( h_dl, "CleanupVocalSipStack");
#endif

martin_yahoo 2009-03-20 11:41 发表评论

martin_yahoo — Wed, 18 Mar 2009 07:37:00 GMT

�Q�互�?mutext)和旗�?semaphore)之间有什么不同？�Q�这��L��问题��短而有力，但要回答却相当困难．即��有经验的实时操作�pȝ��(RTOS)用户在区别如何正��用mutex和semaphore时也存在着困难�Q?br>但这一点很不幸而且很危险，因�ؓ无�Q�q�两�U�原生RTOS中的哪一�U�被错误使用�Q�都会导致嵌入式�pȝ��出现意想不到的错误，特别是这些系�l��ؓ有关生命安全的��品时.
有关mutex和semaphore的荒诞说法是它们是相似的�Q�甚��x��可以互换的．正确的事实是��管mutex和semaphore在它们的执行上有�怼�之处�Q�但是我们还是应该在使用它们时加以区别对待．
最普遍�Q�但也是不正��）的答案是�Q�mutex和semphore非常�怼��Q�它们只有一个区别，那就是semaphores的计数可以超�q?. 差不多所有的工程师都能正��的理解�Q�mutex是一个二�q�制标志�Q�可以通过它来��保执行��在代码关键�?critical section of code)互相排斥,从而对�׃�n资源加一保护�Q�但当他们被要求�q�一步回�{�如何��用＂计算�Ҏ��semaphore"的方式时�Q�大部分工程师的回答��如同教�U�书书一般的��L��---semaphore用于保护多重同类资源�Q?br>通过�c�L��办法�Q�我们很�Ҏ��解释��Z��?多重资源�Q�场景是有缺��L��.如果你认��Z��个mutex是由操作�pȝ��拥有的关键值的话，我们可以很容易地��个别的mutex比喻是城市咖啡店中一间�ʎ室的钥匙�Q�如果你想��用�ʎ室，却找不到钥匙�Q�你��必��d��一个队列中�{�候．同样圎ͼ�mutex则协串行化多��Q务，以取得全域资源的�׃�n�Q��ƈ且�ؓ�{�待队列中的��d��分配一个静候其循序渐进的位�|�．
但这�U�简单的资源保护协议�q�不使用于两间相同�ʎ室的情况�Q�如果把一个semaphore概括��Z��个mutex�Q��其能保护两个或更多相同的资源�Q�那么在我们的比��M��Q�它��p��是放着两把相同钥匙的蓝子，你可以用��M��一把打开��M��一扇�ʎ室的门．
因此�Q�semaphore本��n�q�不能解军_��个相同资源的问题�Q�咖啡店中的客�h可能只知道有一把钥匙，但�ƈ不知道哪间�ʎ室可用．如果你试图以此方式��用semaphore�Q�你��会发现需要更多的状态信�?--它们通常是由不同的mutex所保护的共享资源．
正确使用semaphore是�ؓ了��信号从一��Q务传臛_��一��Q务．mutex意味着取得与释放，使用受保护共享资源的每一�ơ�Q务都是以�q�样的顺序进行．相比之下�Q��用semaphore的�Q务通常不是发送信��P��是�q�入�{�待状态，不可能同时发生．
例如�Q��Q�?可能包含�E�序代码�Q�当按下�Q�电源＂(power)按钮�Ӟ��卛_��提出(如发送信��h��增量)一个特别的semaphore; ��d��2则依据相同的semaphore而用于唤醒显�C�器. 在这�U�情况下�Q�其中一��Q务是信号的生产者，另一��Q务是信号的消费者．

用一个例子来做�ȝ��Q�首先展�C�如何��用mutex�Q?br>/* Task 1 */
mutexWait(mutex_mens_room);
// Safely use shared resource
mutexRelease(mutex_mens_room);

/* Task 2 */
mutexWait(mutex_mens_room);
// Safely use shared resource
mutexRelease(mutex_mens_room);

相应圎ͼ�你��L��采用下列�Ҏ��使用semaphore:
/* Task 1 - Producer */
semPost(sem_power_btn); // Send the signal

/* Task 2 - Consumer */
semPend(sem_power_btn); // Wait for signal

重要的是�Q�semaphores可以被interrupt service routine(ISR)中断服务�E�序用来向task发送信��P��发送一个semaphore是一个非��d��的RTOS行�ؓ�Q��ƈ且ISR安全�Q�因��U�技术排除了在task�U�别的�ؓ了是中断不��能而引��L��错误的可能性，从ISR中发��Z��h��一�U��嵌入式��Y件更加可靠的设计方式.

http://www.embedded.com/columns/guest/210605040?printable=true
http://www.eettaiwan.com/ART_8800557420_676964_NT_a22f6436.HTM

martin_yahoo 2009-03-18 15:37 发表评论

martin_yahoo — Tue, 17 Mar 2009 09:34:00 GMT

摘要: 前一�D�|��_��读symbian文档资料�Q�和Darwin,ICE�{�开源代码，�l�常��到定时器和定时器事�Ӟ��故对定时器的实现�q�行了一些整理，作�ؓ��M��W�记�Q�以防以后忘讎ͼ� 阅读全文

martin_yahoo 2009-03-17 17:34 发表评论

martin_yahoo — Wed, 11 Mar 2009 04:30:00 GMT

在以前的multi-process�E�序�?/span>,process之间通过�׃�n内存、操作系�l�提供的消息对列�Q�命名管道等不同方式�q�行数据传递。�ؓ了减��内存，以及�q�程切换时引发的上下文切换的开销�Q�现在的�pȝ��一般采�?/span>multi-thread 工作方式�?/span>

�?/span>process都有各自独立的地址�I�间�Q��ƈ且是专有的，因此一�?/span>process不能通过指针讉K��另一�?/span>process中的地址�I�间。而属于同一process的各thread�Q�它们共享同一process的地址�I�间�Q�因此一�?/span>thread可以通过指针讉K��另一�?/span>thread中的地址。这��h��们可以在应用中自己定义消息队列，�q�对消息队列的访问进行管理，��化程序�ƈ提高性能�?/span>

�?/span>multi-thread应用中，我们可以使用消息对列来在不同thread之间�q�行消息传递，�q��低各thread之间的藕合�?/span>

它们之间的关�p�d��下：

生��者：向消息队列中放数据的�U�程�?/span>

消费者：从消息队列中取出数据的线�E��?/span>

生��?/span> ----> 消息队列 ----->消费�?/span>

如果应用规定消息队列的最大长度。在寚w��列进行控制时�Q�应该当消息队列满时�Q�可能要让生产者进行等待，直到消息队列中有新的位置可以攑օ�新的消息。当消息队列为空�Ӟ��应该让消费者进行等待，知道有新的消息被加到消息队列中�?/span>

在该模型中有两点需要注意：

1�Q?/span>不同生��者，消费者同时�ƈ发操作消息队列时�Q�对各操作的串行化。这个问题可以通过寚w��列的操作�q�行加锁来实现。它的实现可以参考另一��随�W��?/span>C++同步锁管理的一�U�方法》�?/span>

2�Q?/span>在消息队列�ؓ�I�或满时�Q�应用程序的处理�?/span>

�q�可以在C++中采�?/span>Monitor.�?/span>Monitor中对某种条�g�q�行监控�?/span>

Monitor 对象可以采取的动作：

(1)、等待操�?/span> wait(long timeout = INFINITE), �~�省情况下无限等待下厅R�?/span>

(2)、发信号操作 signal(long count = 1), �~�省情况下激�z�M��个正在消息队列上�q�行�{�代的线�E��?/span>

对于Monitor的实玎ͼ�可以很简单地用下列两�U�方式实玎ͼ�

1�?/span>采用ACE中的ACE_Event, ACE_Thread_Semphore实现�?/span>

2�?/span>采用 ICE�?/span>Cond实现�Q?/span> �?/span>Linux上，Cond实际上是通过pthread_cond_t来实现的�?/span>

martin_yahoo 2009-03-11 12:30 发表评论

martin_yahoo — Mon, 09 Mar 2009 08:07:00 GMT

前段旉��Q�写了一点关于智能指针的东西�Q�有读者反映没有代码比较难懂．现给出源码，�q�稍微加以解�?

��指针�cȝ��到的基类的定�?
template
class HandleBase
{
public:

typedef T element_type;

    T* get() const
    {
        return _ptr;
    }

   //重蝲->操作�W�，�q�回所指对象的指针.

    T* operator->() const
    {
        if(!_ptr)
        {
            //
            // We don't throw directly NullHandleException here to
            // keep the code size of this method to a minimun (the
            // assembly code for throwing an exception is much bigger
            // than just a function call). This maximises the chances
            // of inlining by compiler optimization.
            //
            throwNullHandleException(__FILE__, __LINE__);
        }

return _ptr;
}

// 通过��指针获取所指对象的引用.

    T& operator*() const
    {
        if(!_ptr)
        {
            //
            // We don't throw directly NullHandleException here to
            // keep the code size of this method to a minimun (the
            // assembly code for throwing an exception is much bigger
            // than just a function call). This maximises the chances
            // of inlining by compiler optimization.
            //
            throwNullHandleException(__FILE__, __LINE__);
        }

return *_ptr;
}

    operator bool() const
    {
        return _ptr ? true : false;
    }

    void swap(HandleBase& other)
    {
        std::swap(_ptr, other._ptr);
    }

T* _ptr;

private:

void throwNullHandleException(const char *, int) const;
};

......

// ��指针�c�d��?/p>

template
class Handle : public HandleBase
{
public:

Handle(T* p = 0) //��指针的构造函�?br> {
this->_ptr = p;

        if(this->_ptr)
        {
            this->_ptr->__incRef();         //在构造函��C��增加所指对象的引用计数
        }
    }

    template                  //拯��构造函�?br>    Handle(const Handle& r)
    {
        this->_ptr = r._ptr;

        if(this->_ptr)
        {
            this->_ptr->__incRef();   //在构造函��C��增加所指对象的引用计数
        }
    }

Handle(const Handle& r) //拯��构造函�?br> {
this->_ptr = r._ptr;

        if(this->_ptr)
        {
            this->_ptr->__incRef();    //在构造函��C��增加所指对象的引用计数
        }
    }

    ~Handle()
    {
        if(this->_ptr)
        {
            this->_ptr->__decRef();      //在析构函��C��减少所指对象的引用计数
        }
    }

// 重蝲=操作�W? 要注意所有权 (卻I��对原实例的处�?.

    Handle& operator=(T* p)
    {
        if(this->_ptr != p)
        {
            if(p)
            {
                p->__incRef();      //增加新指对象的引用计�?br>            }

T* ptr = this->_ptr;
this->_ptr = p;

            if(ptr)
            {
                ptr->__decRef();   //减少原来所指对象的引用计数
            }
        }
        return *this;
    }

    template
    Handle& operator=(const Handle& r)
    {
        if(this->_ptr != r._ptr)
        {
            if(r._ptr)
            {
                r._ptr->__incRef();   //增加新指对象的引用计�?br>            }

T* ptr = this->_ptr;
this->_ptr = r._ptr;

            if(ptr)
            {
                ptr->__decRef();      //减少原来所指对象的引用计数
            }
        }
        return *this;
    }

    Handle& operator=(const Handle& r)
    {
        if(this->_ptr != r._ptr)
        {
            if(r._ptr)
            {
                r._ptr->__incRef();            //增加新指对象的引用计�?br>            }

T* ptr = this->_ptr;
this->_ptr = r._ptr;

            if(ptr)
            {
                ptr->__decRef();            //减少原来所指对象的引用计数
            }
        }
        return *this;
    }

跟智能指针配合��用的对象�Q�要能够跟指针智能配合��用，�q�些对象应该是从下列�cȝ��z��cȝ��实例�Q?br>class SimpleShared
{
public:

SimpleShared();
SimpleShared(const SimpleShared&);

    virtual ~SimpleShared()
    {
    }

    SimpleShared& operator=(const SimpleShared&)
    {
        return *this;
    }

    void __incRef()
    {
        assert(_ref >= 0);
        ++_ref;
    }

    void __decRef()
    {
        assert(_ref > 0);
        if(--_ref == 0)               // 如果引用计数�?,则摧毁对象本�w�．
        {
            if(!_noDelete)
            {
                _noDelete = true;
                delete this;
            }
        }
    }

    int __getRef() const
    {
        return _ref;
    }

    void __setNoDelete(bool b)
    {
        _noDelete = b;
    }

private:

int _ref;
bool _noDelete;
};

class Shared
{
public:

Shared();
Shared(const Shared&);

    virtual ~Shared()
    {
    }

    Shared& operator=(const Shared&)
    {
        return *this;
    }

    virtual void __incRef();
    virtual void __decRef();
    virtual int __getRef() const;
    virtual void __setNoDelete(bool);

protected:

#if defined(_WIN32)
    LONG _ref;
#elif defined(ICE_HAS_ATOMIC_FUNCTIONS)
    volatile int _ref;
#else
    int _ref;
    Mutex _mutex;
#endif
    bool _noDelete;
};

martin_yahoo 2009-03-09 16:07 发表评论

欧美岛国在线观看,亚洲毛片在线观看,国产精品久久影院

Linux操作�pȝ��中中断上下文中的互斥

unix �cȝ���l�中的进�E�同步方式�ȝ��

unix �cȝ��l�中的进�E�同步方式�ȝ��