临界区的使用原则：
尽晚使用，尽早退出。
记得释放资源。
临界区：每个进程中访问临界资源的那段代码称为临界区。
一般线程同步都是使用临界区来实现的，临界区是系统级的API，是最高效的一种方法。
当对一个Buffer写入数据时，如果不加入临界区，则会导致写乱，即ABBBBAAAAABBBBBBB....。我们想要的结果为AAAAAAAAA......，或者BBBBBBBBBBBB........
无临界区代码如下(XThread类可以在之前的文章中找到，本文不做赘述)：
#include <iostream>
#include "XThread.h"
#include "windows.h"
using namespace std;
static char buffer[1024] = { 0 };	
class Mythread :public XThread
{
public :
	void Main()
	{
		for (;;)
		{
			int size = sizeof(buffer);
			for (int i = 0; i < size; i++)
			{
				buffer[i] = c;
				Sleep(1);
			}
			buffer[size - 1] = '\0';
			cout <<'['<< buffer<<']'<<endl;
			Sleep(500);
		}
	}
	char c;
};

int main()
{
	Mythread s1;
	Mythread s2;
	s1.c = 'A';
	s2.c = 'B';

	s1.Start();
	s2.Start();

	getchar();
	return 0;
}


使用临界区：
1. 定义临界区变量
CRITICAL_SECTION section;
2. 初始化临近区
InitializeCriticalSection(&section);
3. 进入和离开临界区
EnterCriticalSection(&section);
 LeaveCriticalSection(&section);
使用临界区后的main代码如下：
#include <iostream>
#include "XThread.h"
#include "windows.h"
using namespace std;
static char buffer[1024] = { 0 };	
CRITICAL_SECTION section;
class Mythread :public XThread
{
public :
	void Main()
	{
		for (;;)
		{
			int size = sizeof(buffer);
			EnterCriticalSection(§ion);
			for (int i = 0; i < size; i++)
			{
				buffer[i] = c;
			}
			buffer[size - 1] = '\0';
			cout <<'['<< buffer<<']'<<endl;
			LeaveCriticalSection(§ion);
			Sleep(500);
		}
	}
	char c;
};

int main()
{
	InitializeCriticalSection(§ion);

	Mythread s1;
	Mythread s2;
	s1.c = 'A';
	s2.c = 'B';

	s1.Start();
	s2.Start();

	getchar();
	return 0;
}

1、什么是临界区？
答：每个进程中访问临界资源的那段程序称为临界区（临界资源是一次仅允许一个进程使用的共享资源）。每次只准许一个进程进入临界区，进入后不允许其他进程进入。



2、进程进入临界区的调度原则是：
① 如果有若干进程要求进入空闲的临界区，一次仅允许一个进程进入。②任何时候，处于临界区内的进程不可多于一个。如已有进程进入自己的临界区，则其它所有试图进入临界区的进程必须等待。③进入临界区的进程要在有限时间内退出，以便其它进程能及时进入自己的临界区。④如果进程不能进入自己的临界区，则应让出 CPU，避免进程出现“忙等”现象。

互斥对象是一种最简单的内核对象，用它可以方便的实现对某一资源的互斥访问。因为它是内核对象，因此可以产生信号，实际上，程序中就是利用这一点实现互斥的。  
  如果没记错的话，临界区并不是内核对象，而是系统提供的一种数据结构，程序中可以声明一个该类型变量，之后用它来实现对资源的互斥访问。当欲访问某一临界资源时，先将该临界区加锁（如果临界区不空闲，等待），用完该资源后，将临界区释放。  
  一般，将他们用于线程间的同步，而且通常可以互换使用。  
  如果要实现复杂互斥，应使用其它方法，如信号量内核对象等。临界区对象不能跨越进程，是线程间共享数据区的同步对象；互斥对象可以作为进程间共享数据区的同步对象。

 

一.临界区与临界资源

（一）、概念


并发进程中与共享变量有关的程序段叫“临界区”， 

共享变量代表的资源叫“临界资源”


（二）、临界区调度原则：


互斥使用，有空让进

忙则等待，有限等待

择一而入，算法可行


二、实现临界区的管理

(一)、Peterson算法


•bool inside[2];

•inside[0]=false;

•inside[1]=false;

•enum {0,1} turn;


•cobegin

•process P0( ) {                   

•  inside[0]=true;                   

•  turn=1;                              

•  while(inside[1]&&turn==1);        

•  /*临界区*/;                     

•  inside[0]=false;                  

• }            


•   process P1( ) {

•       inside[1]=true;

•       turn=0;

•      while(inside[0]&&turn==0);

•  {临界区};                    

•     inside[1]=false;

• }                                 




 （二）、实现临界期管理的硬件设施关中断


1、关中断：最简单的方法

2、测试并设置指令：

TS指令管理临界区时，可把一个临区与一个布尔变量s相连，由于变量s代表了临界资源的状态，可把它看成一把锁。 

3、对换指令


 

 

 

简介
每个进程中访问临界资源的那段代码称为临界区（Critical Section） （临界资源是一次仅允许一个进程使用的共享资源）。

每次只准许一个进程进入临界区，进入后不允许其他进程进入。不论是硬件临界资源，还是软件临界资源，多个进程必须互斥地对它进行访问。

多个进程中涉及到同一个临界资源的临界区称为相关临界区。
注：多线程并发访问全局变量也是临界区问题
程序调度法则
进程进入临界区的调度原则是：

如果有若干进程要求进入空闲的临界区，一次仅允许一个进程进入。
任何时候，处于临界区内的进程不可多于一个。如已有进程进入自己的临界区，则其它所有试图进入临界区的进程必须等待。
进入临界区的进程要在有限时间内退出，以便其它进程能及时进入自己的临界区。
如果进程不能进入自己的临界区，则应让出CPU，避免进程出现“忙等”现象

FreeRTOS解决方法
访问一个被多任务共享，或是被多任务和中断共享的资源时，需要采用“互斥”技术以保证数据在任何时候都保持一致性。这样做的目的是要确保任务从开始访问资源就具有排它性，直到这个资源又恢复到完整状态。
基本临界区
基本临界区是指宏taskENTER_CRITICAL()和taskEXIT_CRITICAL()之间的代码区间。也被称为Critical Section或者Critical Regions. 使用方法如下：
// 为了保证PORTA的访问不被中断，将访问操作放入临界区运行
taskENTER_CRITICAL();        //进入基本临界区
 
// 在taskENTER_CRITICAL()和taskEXIT_CRITICAL()之间不会切换到其他任务，中断可以执行，也允许嵌
//套，但只是针对优先级高于configMAX_SYSCALL_INTERRUPT_PRIORITY的任务，而且这些中断不允许访问
//FreeRTOS的API函数。
 
PORTA |= 0x01;
 
 
taskEXIT_CRITICAL();        //退出基本临界区

临界区是提供互斥功能的一种非常原始的实现方法。临界区的工作 仅仅是简单的把中断全部关掉，或者是关掉优先级在configMAX_SYSCALL_INTERRUPT_PRIORITY以下的中断-依赖具体使用的FreeRTOS移植。抢占式的上下文切换只可能在某中断中完成，因此调用taskENTER_CRITICAL()可以在中断关闭的时段一直保持持续运行状态直到退出临界区。
临界区必须具有很短的时间，否则会反过来影响中断的响应时间。在每次使用taskENTER_CRITICAL()之后必须尽快的配套一个taskEXIT_CRITICAL()来退出临界区。
使用信号量或者互斥量
推荐使用互斥量，因为互斥量解决了优先级翻转的问题
void process_data(void)
{
    if(xSemaphoreTake(xSemaphore, 10) == pdTRUE)
    {
        x++;
        xSemaphoreGive( xSemaphore );
    }
}

信号量和互斥量的最大区别是
（1）用于互斥的信号量必须归还

（2）用于同步的信号量在完成同步后变丢弃，不需要归还
禁止任务调度
vTaskSuspendAll(void);   //挂起调度器创建临界区(禁止任务调度 suspend the scheduler)
 
/*
   通过vTaskSuspendAll()来挂起调度器。挂起调度器可以停止上下文切换而不用关中断，如果某个中断在调
度器挂起过程中要求进行上下文切换，则这个要求也会被挂起，直到调度器被唤醒后才会得到执行。
*/
 
vTaskResumeAll(void);  //（解除禁止任务调度 resuming the scheduler； 成对使用）
/*
返回值：pdTRUE: 
   在调度器挂起过程中，上下文切换请求也会被挂起，直到调度器唤醒才被执行，如果一个挂起的上下文切换请求在vTaskResumeAll()返回前得到执行，则返回pdTRUE.
返回值：pdFALSE:
   如果是其他情况，则返回pdFALSE.
*/
 
// 注意1：两个函数成对使用；
// 注意2：两者之间不能调用FreeRTOS系统API.

如果一段临界区太长而不适合简单的关中断来实现，可以考虑采用挂起调度器的方式

唤醒调度器是一个相对较长的操作

基本临界区是保护一段代码区间不被其他任务或中断打断。而由挂起调度器实现的临界区只能保护一段代码不被其他任务打断，并不能约束中断，因为在这种方式下，中断是使能的。

调度器处于挂起状态时，不能调用FreeRTOS的API函数。