VxWorks信号量是提供任务间通信、同步和互斥的最优选择，提供任务间最快速的通信。也是提供任务间同步和互斥的主要手段。VxWorks提供3种信号量来解决不同的问题。
二进制信号量：最快的最常用的信号量，可用于同步或互斥。
互斥信号量：为了解决内在的互斥问题如优先级继承、删除安全和递归等情况而最优化的特殊的二进制信号量。
计数信号量：类似于二进制信号量，但是随信号量释放的次数改变而改变。
二进制信号量
二进制信号量能够满足任务间的互斥和同步，需要的系统开销最小，因此也称快速信号量。二进制信号量可以看成一个标志，对应资源是可用还是不可用。当一个任务调用semTake ()请求一个信号量时，如果此时信号量可用，信号量会被清零，并且任务立即继续执行；如果信号量不可用，任务会被阻塞来等待信号量。
当一个任务调用semGive ()释放一个二进制信号量时。如果信号量已经可用，释放信号量不会产生任何影响；如果信号量不可用并且没有任务等待使用该信号量，信号量只是被简单地置为可用；如果信号量不可用并且有一个或多个任务等待该信号量，最高优先级的任务被解阻塞，信号量仍为不可用。
互斥
当两个以上的任务共享使用同一块内存缓冲区或同一个I/O设备之类的资源时，可能会发生竞争状态。
二进制信号量可以通过对共享资源上锁，实现高效的互斥访问，不象禁止中断或禁止抢占，二进制信号量将互斥仅仅限于对与之联系的资源的访问，并且比禁止中断和禁止抢占提供更精确的互斥粒度。使用时创建用于保护资源的二进制信号量，初始时信号量可用。
当任务需要访问这个资源时，首先取得这个信号量，所有其它想要访问这个资源的任务将被阻塞。当任务完成了对该资源的访问时，释放该信号量，允许其他任务使用该资源。因此所有对一个需要互斥访问资源的操作由semTake ()和semGive ()对一起来实现。
semTake(semMutex，WAIT FOREVER)
临界区，某一时刻仅被一个任务访问
semGive (semMutex)
同步
信号量另一种通常的用法是用于任务间的同步机制。在这种情况下，信号量代表一个任务所等待的条件或事件。最初，信号量是不可用的。一个任务或中断处理程序释放该信号量来通知这个事件的发生。等待该信号量的任务将被阻塞直到事件发生、该信号量可用。一旦被解阻塞，任务就执行恰当的事件处理程序。信号量在任务同步中的应用对于将中断服务程序从冗长的事件处理中解放出来以缩短中断响应时间是很有用的。
互斥信号量
互斥信号量是一种特殊的二进制信号量，用于解决具有内在的互斥问题：优先级继承、删除安全和对资源的递归访问等情况。
对于一般的操作系统，一般互斥信号量就是二值信号靓量，但VxWoks中有非同寻常的意义。另外一个典型就是，Linux内核也单独设立了互斥信号量。
互斥信号量与二进制不同点在于：
①定义一个互斥信号量时，其已经初始化完毕为可用，它仅用于互斥；
②仅能由取(semTake ())它的任务释放，即由同一个任务申请然后使用完毕后释放；
③因为semTake和semGive是成对出现的，因此不能在ISR 中释放(semGive ())。
优先级继承
优先级倒置发生在一个高优先级的任务被迫等待一段不确定时间，等待一个低优先级任务完成。VxWorks允许使用优先级继承算法，在互斥信号量中使用选项SEM-INVERSION-SAFE ，将使能优先级继承算法，优先级继承协议确保拥有资源的任务以阻塞在该资源上的所有任务中优先级最高的任务的优先级执行，直到它释放所拥有的所有信号量，然后该任务返回到正常状态。因此这个“继承的高优先级”任务受到不会被任何中间优先级任务抢占的保护。
删除安全
另一个互斥问题涉及到任务删除。在一个受信号量保护的临界区，经常需要保护在临界区执行的任务不会被意外地删除。删除一个在临界区执行的任务可能引起意想不到的后果，造成保护资源的信号量不可用，可能导致资源处于破坏状态，也就导致了其他要访问该资源的所有任务无法得到满足。
原语taskSafe()和taskUnsafe ()提供了防止任务被意外删除的一种方法。同时互斥信号量提供了选项SEM-DELETE-SAFE ，使用这个选项，每次调用semTake ( )时隐含地使能了taskSafe()，当每次调用semGive ()时隐含地使能了taskUnsafe ()这种方式，任务得到信号量时得到不会被删除的保护。
递归资源访问
互斥信号量能够被递归地获得。这意味着信号量能够被一个拥有该信号量的任务在该信号量最终被释放之前多次获取。递归对于满足一些子程序即要求能够相互调用但是也要求互斥访问一个资源非常有用。这种情形是可能的，因为系统需要跟踪哪一个任务当前拥有信号量。
计数器信号量
计数器信号量是实现任务同步和互斥的另一种手段，在具体实现上有点差异。计数器信号量除了像二进制信号量那样工作外，还保持对信号量释放次数的跟踪。与二进制信号量不同的时，计数型信号量每次释放，计数器加一；每次获取，计数器减一，当信号量减到0 时，试图获取该信号量的任务被阻塞。
正如二进制信号量，当计数信号量释放时，如果有任务阻塞在该信号量阻塞队列上，那么任务解除阻塞；但是如果信号量释放时，没有任务阻塞在该信号量阻塞队列上，那么计数器加一。
结 论
通过对嵌入式操作系统VxWorks的多任务之间的通信机制的分析可以看出，信号量在实现多任务间的通信、同步和互斥中发挥着重要的作用。因此，深入理解和正确使用VxWorks的信号量，可以提高实时系统中多任务间通信的效率
硬件看门狗实际上就是一个定时器，有一个输入和输出，它的功能是定期检查芯片内部的情况，一旦发生错误就向芯片发出重启信号。实际上，就是监控芯片。
由于单片机系统在工作的时候，容易受到外界电磁场的干扰，造成数据混乱，程序出错，导致死循环，影响单片机的正常工作，从而导致单片机控制系统发生不可预料的后果。
使用硬件看门狗，可以预防程序发生死循环。应用看门狗电路后单片机可以在无人状态下连续工作。硬件看门口电路，利用一个定时器来监控主程序的运行。
扩展资料
注意事项：
大多数51 系列单片机都有看门狗，当看门狗没有被定时清零时，将引起复位。这可防止程序跑飞。也可以防止程序在线运行时候出现死循环。
设计者必须清楚看门狗的溢出时间以决定在合适的时候，清看门狗。清看门狗也不能太过频繁否则会造成资源浪费，程序正常运行时，软件每隔一定的时间（小于定时器的溢出周期）给定时器置数，即可预防溢出中断而引起的误复位。
参考资料来源：百度百科--看门狗 （监控芯片）
参考资料来源：百度百科--看门狗（监控软件）
1． 哲学家进餐问题：(1) 在什么情况下5 个哲学家全部吃不上饭？
考虑两种实现的方式，如下：
A.
算法描述：
void philosopher(int i) /*i：哲学家编号，从0 到4*/
{
while (TRUE) {
think( )/*哲学家正在思考*/
take_fork(i)/*取左侧的筷子*/
take_fork((i+1) % N)/*取左侧筷子；％为取模运算*/
eat( )/*吃饭*/
put_fork(i)/*把左侧筷子放回桌子*/
put_fork((i+1) % N)/*把右侧筷子放回桌子*/
}
}
分析：假如所有的哲学家都同时拿起左侧筷子，看到右侧筷子不可用，又都放下左侧筷子，
等一会儿，又同时拿起左侧筷子，如此这般，永远重复。对于这种情况，即所有的程序都在
无限期地运行，但是都无法取得任何进展，即出现饥饿，所有哲学家都吃不上饭。
B．
算法描述：
规定在拿到左侧的筷子后，先检查右面的筷子是否可用。如果不可用，则先放下左侧筷子，
等一段时间再重复整个过程。
分析：当出现以下情形，在某一个瞬间，所有的哲学家都同时启动这个算法，拿起左侧的筷
子，而看到右侧筷子不可用，又都放下左侧筷子，等一会儿，又同时拿起左侧筷子……如此
这样永远重复下去。对于这种情况，所有的程序都在运行，但却无法取得进展，即出现饥饿，
所有的哲学家都吃不上饭。
(2) 描述一种没有人饿死（永远拿不到筷子）算法。
考虑了四种实现的方式（A、B、C、D）：
A．原理：至多只允许四个哲学家同时进餐,以保证至少有一个哲学家能够进餐,最终总会释
放出他所使用过的两支筷子,从而可使更多的哲学家进餐。以下将room 作为信号量，只允
许4 个哲学家同时进入餐厅就餐，这样就能保证至少有一个哲学家可以就餐，而申请进入
餐厅的哲学家进入room 的等待队列，根据FIFO 的原则，总会进入到餐厅就餐，因此不会
出现饿死和死锁的现象。
伪码：
semaphore chopstick[5]={1，1，1，1，1}
semaphore room=4
void philosopher(int i)
{
while(true)
{
think()
wait(room)//请求进入房间进餐
wait(chopstick[i])//请求左手边的筷子
wait(chopstick[(i+1)%5])//请求右手边的筷子
eat()
signal(chopstick[(i+1)%5])//释放右手边的筷子
signal(chopstick[i])//释放左手边的筷子
signal(room)//退出房间释放信号量room
}
}
B．原理：仅当哲学家的左右两支筷子都可用时,才允许他拿起筷子进餐。
方法1：利用AND 型信号量机制实现：根据课程讲述，在一个原语中，将一段代码同时需
要的多个临界资源，要么全部分配给它，要么一个都不分配，因此不会出现死锁的情形。当
某些资源不够时阻塞调用进程由于等待队列的存在，使得对资源的请求满足FIFO 的要求，
因此不会出现饥饿的情形。
伪码：
semaphore chopstick[5]={1，1，1，1，1}
void philosopher(int I)
{
while(true)
{
think()
Swait(chopstick[(I+1)]%5,chopstick[I])
eat()
Ssignal(chopstick[(I+1)]%5,chopstick[I])
}
}
方法2：利用信号量的保护机制实现。通过信号量mutex对eat（）之前的取左侧和右侧筷
子的操作进行保护，使之成为一个原子操作，这样可以防止死锁的出现。
伪码：
semaphore mutex = 1
semaphore chopstick[5]={1，1，1，1，1}
void philosopher(int I)
{
while(true)
{
think()
wait(mutex)
wait(chopstick[(I+1)]%5)
wait(chopstick[I])
signal(mutex)
eat()
signal(chopstick[(I+1)]%5)
signal(chopstick[I])
}
}
C． 原理：规定奇数号的哲学家先拿起他左边的筷子,然后再去拿他右边的筷子而偶数号
的哲学家则相反.按此规定,将是1,2号哲学家竞争1号筷子,3,4号哲学家竞争3号筷子.即
五个哲学家都竞争奇数号筷子,获得后,再去竞争偶数号筷子,最后总会有一个哲学家能获
得两支筷子而进餐。而申请不到的哲学家进入阻塞等待队列，根FIFO原则，则先申请的哲
学家会较先可以吃饭，因此不会出现饿死的哲学家。
伪码：
semaphore chopstick[5]={1，1，1，1，1}
void philosopher(int i)
{
while(true)
{
think()
if(i%2 == 0) //偶数哲学家，先右后左。
{
wait (chopstick[ i + 1 ] mod 5)
wait (chopstick[ i])
eat()
signal (chopstick[ i + 1 ] mod 5)
signal (chopstick[ i])
}
Else //奇数哲学家，先左后右。
{
wait (chopstick[ i])
wait (chopstick[ i + 1 ] mod 5)
eat()
signal (chopstick[ i])
signal (chopstick[ i + 1 ] mod 5)
}
}
D．利用管程机制实现（最终该实现是失败的，见以下分析）：
原理：不是对每只筷子设置信号量，而是对每个哲学家设置信号量。test()函数有以下作
用：
a. 如果当前处理的哲学家处于饥饿状态且两侧哲学家不在吃饭状态，则当前哲学家通过
test()函数试图进入吃饭状态。
b. 如果通过test()进入吃饭状态不成功，那么当前哲学家就在该信号量阻塞等待，直到
其他的哲学家进程通过test()将该哲学家的状态设置为EATING。
c. 当一个哲学家进程调用put_forks()放下筷子的时候，会通过test()测试它的邻居，
如果邻居处于饥饿状态，且该邻居的邻居不在吃饭状态，则该邻居进入吃饭状态。
由上所述,该算法不会出现死锁，因为一个哲学家只有在两个邻座都不在进餐时，才允
许转换到进餐状态。
该算法会出现某个哲学家适终无法吃饭的情况，即当该哲学家的左右两个哲学家交替
处在吃饭的状态的时候，则该哲学家始终无法进入吃饭的状态，因此不满足题目的要求。
但是该算法能够实现对于任意多位哲学家的情况都能获得最大的并行度，因此具有重要
的意义。
伪码：
#define N 5 /* 哲学家人数*/
#define LEFT (i-1+N)%N /* i的左邻号码 */
#define RIGHT (i+1)%N /* i的右邻号码 */
typedef enum { THINKING, HUNGRY, EATING } phil_state/*哲学家状态*/
monitor dp /*管程*/
{
phil_state state[N]
semaphore mutex =1
semaphore s[N]/*每个哲学家一个信号量，初始值为0*/
void test(int i)
{
if ( state[i] == HUNGRY &&state[LEFT(i)] != EATING &&
state[RIGHT(i)] != EATING )
{
state[i] = EATING
V(s[i])
}
}
void get_forks(int i)
{
P(mutex)
state[i] = HUNGRY
test(i)/*试图得到两支筷子*/
V(mutex)
P(s[i])/*得不到筷子则阻塞*/
}
void put_forks(int i)
{
P(mutex)
state[i]= THINKING
test(LEFT(i))/*看左邻是否进餐*/
test(RIGHT(i))/*看右邻是否进餐*/
V(mutex)
}
}
哲学家进程如下：
void philosopher(int process)
{
while(true)
{
think()
get_forks(process)
eat()
put_forks(process)
}
}
欢迎分享，转载请注明来源：夏雨云
微信扫一扫
支付宝扫一扫
评论列表（0条）