通过阅读@FiddlingBits 和@ensc 的现有答案，我认为我可以提供一种不同的方法。
你说你的Flash芯片不能进行内存映射。这是一个相当大的限制，但我们可以解决它。
是的，您可以提前运行复制例程。只要将它放入RAM中就可以执行它。
DMA 使其更快：
如果您有外设 DMA 控制器（例如 Atmel SAM3N 系列上提供的控制器），那么您可以使用 DMA 控制器复制内存块，同时您的处理器执行实际有用的操作。
MMU 使其更简单：
如果您有可用的 MMU，那么您可以轻松地做到这一点，只需选择您想要执行代码的 RAM 区域，将代码复制到其中，并在每次出现页面错误时，将正确的代码重新加载到同一区域中。然而，这已经由 @ensc 提出，所以我还没有添加任何新内容。
注意：如果不清楚，MMU 与 MPU 不同
没有 MMU 解决方案，但有 MPU 可用：
如果没有 MMU，任务会有点棘手，但仍然可以完成。您需要了解编译器如何生成代码并阅读有关位置无关代码 (PIC) http://eli.thegreenplace.net/2011/11/03/position-independent-code-pic-in-shared-libraries/。然后你需要在 RAM 中分配一个区域来执行你的外部闪存芯片从中复制代码并将其部分复制到其中（确保从正确的位置开始执行它）。 MPU 需要配置为在任务尝试访问其指定区域之外的内存时生成错误，然后您需要获取正确的内存（这可能会成为一个复杂的过程）、重新加载并继续执行。
没有 MMU 和 MPU 可用：
如果您没有 MMU，这项任务现在就变得非常困难。在这两种情况下，您都对大小有严格的限制外部代码可。基本上，存储在外部闪存芯片上的代码现在必须能够适合exactly在 RAM 中分配的区域内，您将在其中执行它。如果您可以将该代码拆分为彼此不交互的单独任务，那么您就可以做到这一点，否则您就做不到。
如果您要生成 PIC，那么您只需编译任务并将它们按顺序放置在内存中即可。否则，您将需要使用链接器脚本来控制代码生成，以便存储在外部闪存中的每个已编译任务将从 RAM 中的相同预定义位置执行（这将要求您了解LD 叠加 ftp://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_node/ld_22.html或单独编译它们）。
Summary:
为了更完整地回答你的问题，我需要知道你正在使用什么芯片和什么操作系统。有多少可用内存也可以帮助我更好地了解您的限制。
但是，您询问是否可以一次加载多个任务来运行。如果你像我建议的那样使用 PIC 应该是可以的。如果没有，那么您需要提前决定每个任务将在哪里运行，并且这将能够同时加载/运行某些组合。
最后，根据您的系统和芯片，这可能很容易也可能很困难。
EDIT 1:
给出的附加信息：
- 芯片是SAM7S（Atmel）
- 它确实有一个外设 DMA 控制器。
- 它没有 MMU 或 MPU。
- 8K 内部 RAM，这对我们来说是一个限制。
- 安装定制的操作系统后，它还剩下大约 28K 的闪存。
提出的其他问题：
- 理想情况下，我想将程序复制到闪存空间并从那里执行它们。理论上这是可能的。难道不可能一条一条地执行程序吗？
是的，可以逐条指令执行程序（但这种方法也有一个限制，我将在稍后介绍）。首先，您将在内存中分配单个指令所在的地址（4 字节对齐）。它的宽度为 32 位（4 字节），紧随其后您可以放置第二条永远不会更改的指令。这第二条指令将是一个主管呼叫 (SVC) http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0471c/BABFGEFG.html这会引发一个中断，允许您获取下一条指令，将其放入内存中并重新开始。
尽管可能不建议这样做，因为您将花费更多时间进行上下文切换而不是执行代码，您实际上不能使用变量（您需要使用 RAM），您不能使用函数调用（除非您手动处理分支）指令，哎呀！）并且你的闪存将被写入太多，以至于它很快就会变得毫无用处。关于最后一个，关于闪存变得无用，我假设你想从 RAM 中逐条执行指令。除了所有这些限制之外，您还将仍然需要使用一些内存用于您的堆栈、堆和全局变量（有关详细信息，请参阅我的附录）。这个区域可以是shared所有任务都从外部闪存运行，但您需要为此编写一个自定义链接器脚本，否则您将浪费 RAM。
了解 C 代码的编译方式将使您更清楚这一点。即使您使用 C++，首先也要问自己这个问题，我的设备上的变量和指令编译到哪里?
基本上，在尝试此操作之前您必须了解的是：
- 代码执行的位置（闪存/RAM）
- 该代码如何链接到其堆栈、堆和全局变量（您可以为此任务分配一个单独的堆栈，并为全局变量分配单独的空间，但您可以共享堆）.
- 该外部代码的堆栈、堆和全局变量所在的位置（我试图暗示您需要对 C 代码有多少控制权）
Edit 2:
如何使用外设 DMA 控制器：
对于我正在使用的微控制器，DMA 控制器实际上没有连接到嵌入式闪存进行读取或写入。如果您也遇到这种情况，则无法使用它。但是，您的数据表在这方面尚不清楚，我怀疑您需要使用串行端口运行测试，看看它是否真的可以工作。
除此之外，我担心使用 DMA 控制器时的写入操作可能比手动执行更复杂，因为缓存页面写入。您需要确保仅在页内进行 DMA 传输，并且 DMA 传输永远不会跨越页边界。另外，我不确定当您告诉 DMA 控制器从闪存写回到同一位置时会发生什么（您可能需要这样做以确保只覆盖正确的部分）。
关于可用闪存和 RAM 的问题：
我担心您之前关于一次执行一条指令的问题。如果是这样的话，那么你不妨写一个解释器。
如果您没有足够的内存来包含需要执行的任务的完整代码，那么您需要将任务编译为 PIC，并将全局偏移表 (GOT) 与该任务所需的所有内存一起放置在 ram 中任务的全局变量。这是解决没有足够空间来完成整个任务的唯一方法。您还必须为其堆栈分配足够的空间。
如果您没有足够的 RAM（我怀疑您不会），则每次您需要在外部闪存芯片上的任务之间进行更改时，您可以将 RAM 内存换出并将其转储到闪存中，但我再次强烈建议您不要编写多次到您的闪存。这样，您就可以使外部闪存上的任务为其全局变量共享一块 RAM。
对于所有其他情况，您将编写一个解释器。我什至做了不可想象的事情，我试图想出一种方法来使用微控制器内存控制器的中止状态（第 18.3.4 节中止状态）数据表 http://www.atmel.com/Images/doc6175.pdf）作为 MPU，但未能找到一种甚至远程聪明的方法来使用它。
Edit 3:
我建议阅读 40.8.2 非易失性存储器 (NVM) 位数据表 http://www.atmel.com/Images/doc6175.pdf这表明你的闪存最多有 10,000 次写入/擦除周期（我花了一段时间才找到它）。这意味着当您写入和擦除 Flash 区域时，您将在其中进行 10,000 次上下文切换任务，Flash 的该部分将变得无用。
APPENDIX
请简短阅读这个博客条目 http://www.geeksforgeeks.org/memory-layout-of-c-program/在继续阅读下面我的评论之前。
C 变量位于嵌入式 ARM 芯片上的位置：
我学习得最好的不是从抽象的概念，而是从具体的例子，所以我会尝试给你提供代码来使用。基本上所有的魔法都发生在链接器脚本中。如果您阅读并理解它，您将看到您的代码会发生什么。现在我们来剖析一下：
OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm")
OUTPUT_ARCH(arm)
SEARCH_DIR(.)
/* Memory Spaces Definitions */
MEMORY
{
/* Here we are defining the memory regions that we will be placing
* different sections into. Different regions have different properties,
* for example, Flash is read only (because you need special instructions
* to write to it and writing is slow), while RAM is read write.
* In the brackets after the region name:
* r - denotes that reads are allowed from this memory region.
* w - denotes that writes are allowed to this memory region.
* x - means that you can execute code in this region.
*/
/* We will call Flash rom and RAM ram */
rom (rx) : ORIGIN = 0x00400000, LENGTH = 0x00040000 /* flash, 256K */
ram (rwx) : ORIGIN = 0x20000000, LENGTH = 0x00006000 /* sram, 24K */
}
/* The stack size used by the application. NOTE: you need to adjust */
STACK_SIZE = DEFINED(STACK_SIZE) ? STACK_SIZE : 0x800 ;
/* Section Definitions */
SECTIONS
{
.text :
{
. = ALIGN(4);
_sfixed = .;
KEEP(*(.vectors .vectors.*))
*(.text .text.* .gnu.linkonce.t.*)
*(.glue_7t) *(.glue_7)
*(.rodata .rodata* .gnu.linkonce.r.*) /* This is important, .rodata is in Flash */
*(.ARM.extab* .gnu.linkonce.armextab.*)
/* Support C constructors, and C destructors in both user code
and the C library. This also provides support for C++ code. */
. = ALIGN(4);
KEEP(*(.init))
. = ALIGN(4);
__preinit_array_start = .;
KEEP (*(.preinit_array))
__preinit_array_end = .;
. = ALIGN(4);
__init_array_start = .;
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array))
__init_array_end = .;
. = ALIGN(0x4);
KEEP (*crtbegin.o(.ctors))
KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*crtend.o(.ctors))
. = ALIGN(4);
KEEP(*(.fini))
. = ALIGN(4);
__fini_array_start = .;
KEEP (*(.fini_array))
KEEP (*(SORT(.fini_array.*)))
__fini_array_end = .;
KEEP (*crtbegin.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*crtend.o(.dtors))
. = ALIGN(4);
_efixed = .; /* End of text section */
} > rom /* All the sections in the preceding curly braces are going to Flash in the order that they were specified */
/* .ARM.exidx is sorted, so has to go in its own output section. */
PROVIDE_HIDDEN (__exidx_start = .);
.ARM.exidx :
{
*(.ARM.exidx* .gnu.linkonce.armexidx.*)
} > rom
PROVIDE_HIDDEN (__exidx_end = .);
. = ALIGN(4);
_etext = .;
/* Here is the .relocate section please pay special attention to it */
.relocate : AT (_etext)
{
. = ALIGN(4);
_srelocate = .;
*(.ramfunc .ramfunc.*);
*(.data .data.*);
. = ALIGN(4);
_erelocate = .;
} > ram /* All the sections in the preceding curly braces are going to RAM in the order that they were specified */
/* .bss section which is used for uninitialized but zeroed data */
/* Please note the NOLOAD flag, this means that when you compile the code this section won't be in your .hex, .bin or .o files but will be just assumed to have been allocated */
.bss (NOLOAD) :
{
. = ALIGN(4);
_sbss = . ;
_szero = .;
*(.bss .bss.*)
*(COMMON)
. = ALIGN(4);
_ebss = . ;
_ezero = .;
} > ram
/* stack section */
.stack (NOLOAD):
{
. = ALIGN(8);
_sstack = .;
. = . + STACK_SIZE;
. = ALIGN(8);
_estack = .;
} > ram
. = ALIGN(4);
_end = . ;
/* heap extends from here to end of memory */
}
这是为 SAM3N 自动生成的链接描述文件（您的链接描述文件应该仅在内存区域定义上有所不同）。现在，让我们看一下设备在断电后启动时会发生什么情况。
首先发生的事情是 ARM 内核读取存储在闪存向量表中的地址，该地址指向您的重置向量。重置向量只是一个函数，对我来说它也是由 Atmel Studio 自动生成的。这里是：
void Reset_Handler(void)
{
uint32_t *pSrc, *pDest;
/* Initialize the relocate segment */
pSrc = &_etext;
pDest = &_srelocate;
/* This code copyes all of the memory for "initialised globals" from Flash to RAM */
if (pSrc != pDest) {
for (; pDest < &_erelocate;) {
*pDest++ = *pSrc++;
}
}
/* Clear the zero segment (.bss). Since it in RAM it could be anything after a reset so zero it. */
for (pDest = &_szero; pDest < &_ezero;) {
*pDest++ = 0;
}
/* Set the vector table base address */
pSrc = (uint32_t *) & _sfixed;
SCB->VTOR = ((uint32_t) pSrc & SCB_VTOR_TBLOFF_Msk);
if (((uint32_t) pSrc >= IRAM_ADDR) && ((uint32_t) pSrc < IRAM_ADDR + IRAM_SIZE)) {
SCB->VTOR |= 1 << SCB_VTOR_TBLBASE_Pos;
}
/* Initialize the C library */
__libc_init_array();
/* Branch to main function */
main();
/* Infinite loop */
while (1);
}
现在，请耐心等待我解释您编写的 C 代码如何适应所有这些。
考虑以下代码示例：
int UninitializedGlobal; // Goes to the .bss segment (RAM)
int ZeroedGlobal[10] = { 0 }; // Goes to the .bss segment (RAM)
int InitializedGlobal[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 11 }; // Goes to the .relocate segment (RAM and FLASH)
const int ConstInitializedGlobal[10] = { 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 }; // Goes to the .rodata segment (FLASH)
void function(int parameter)
{
static int UninitializedStatic; // Same as UninitializedGlobal above.
static int ZeroedStatic = 0; // Same as ZeroedGlobal above.
static int InitializedStatic = 7; // Same as InitializedGlobal above.
static const int ConstStatic = 18; // Same as ConstInitializedGlobal above. Might get optimized away though, lets assume it doesn't.
int UninitializedLocal; // Stacked. (RAM)
int ZeroedLocal = 0; // Stacked and then initialized (RAM)
int InitializedLocal = 7; // Stacked and then initialized (RAM)
const int ConstLocal = 91; // Not actually sure where this one goes. I assume optimized away.
// Do something with all those lovely variables...
}
