The main difference between a single- and a multi-threaded application is that the former has one stack and the latter has one for each thread. Code is generated somewhat differently since the compiler will assume that the data and stack segment registers (ds and ss) are not equal. This means that indirection through the ebp and esp registers that default to the ss register won't also default to ds (because ds!=ss). Conversely, indirection through the other registers which default to ds won't default to ss.

The threads share everything else including data and code areas. They also share lib routines so make sure that they are thread-safe. A procedure that sorts an area in RAM can be multi-threaded to speed things up. The threads will then be accessing, comparing and ordering data in the same physical memory area and executing the same code but using different local variables to control their respective part of the sort. This of course is because the threads have different stacks where the local variables are contained. This type of programming requires careful tuning of the code so that inter-core data collisions (in caches and RAM) are reduced which in turn results in a code which is faster with two or more threads than it is with just one. Of course, an un-tuned code will often be faster with one processor than with two or more. To debug is more challenging because the standard "int 3" breakpoint will not be applicable since you want to interrupt a specific thread and not all of them. Debug register breakpoints do not solve this problem either unless you can set them on the specific processor executing the specific thread you want to interrupt.

其他多线程代码可能涉及在程序的不同部分运行的不同线程。这种类型的编程不需要同样的调优，因此更容易学习。

如果你在写优化 多核编译器/字节码虚拟机 中央处理器，你需要知道什么 特别是关于x86的制作 它生成有效运行的代码 在所有的核上?

作为编写优化编译器/字节码虚拟机的人，我可能能够在这里帮助你。

您不需要特别了解x86，就可以让它生成跨所有核心高效运行的代码。

但是，您可能需要了解cmpxchg及其相关知识，以便编写能够在所有核心上正确运行的代码。多核编程要求在执行线程之间使用同步和通信。

您可能需要了解一些关于x86的知识，以便让它生成在x86上高效运行的代码。

你还可以学习其他一些有用的东西:

您应该了解操作系统(Linux或Windows或OSX)提供的允许您运行多个线程的功能。你应该学习并行化api，比如OpenMP和Threading Building Blocks，或者OSX 10.6“Snow Leopard”即将推出的“Grand Central”。

您应该考虑编译器是否应该自动并行，或者编译器编译的应用程序的作者是否需要在他的程序中添加特殊的语法或API调用来利用多核。

这不是对问题的直接回答，但这是对评论中出现的一个问题的回答。本质上，问题是硬件对多核操作提供了什么支持，即同时运行多个软件线程的能力，而无需在它们之间进行软件上下文切换。(有时称为SMP系统)。

Nicholas Flynt had it right, at least regarding x86. In a multi-core environment (Hyper-threading, multi-core or multi-processor), the Bootstrap core (usually hardware-thread (aka logical core) 0 in core 0 in processor 0) starts up fetching code from address 0xfffffff0. All the other cores (hardware threads) start up in a special sleep state called Wait-for-SIPI. As part of its initialization, the primary core sends a special inter-processor-interrupt (IPI) over the APIC called a SIPI (Startup IPI) to each core that is in WFS. The SIPI contains the address from which that core should start fetching code.

这种机制允许每个核心从不同的地址执行代码。所需要的只是为每个硬件核心提供软件支持，以便建立自己的表和消息队列。

操作系统使用它们来执行软件任务的实际多线程调度。(一个正常的操作系统只需要在启动时启动一次其他内核，除非你是热插拔cpu，例如在虚拟机中。这与启动或将软件线程迁移到这些内核是分开的。每个核心都在运行内核，如果没有其他事情要做，内核就会调用sleep函数来等待中断。)

就实际的程序集而言，正如Nicholas所写的，单线程应用程序集和多线程应用程序集之间没有区别。每个核都有自己的寄存器集(执行上下文)，因此编写:

mov edx, 0

将只更新当前运行线程的EDX。没有办法使用单一的汇编指令在另一个处理器上修改EDX。您需要某种类型的系统调用来要求操作系统告诉另一个线程运行将更新自己的EDX的代码。

根据我的理解，每个“核心”都是一个完整的处理器，有自己的寄存器集。基本上，BIOS启动时只运行一个核心，然后操作系统可以通过初始化其他核心并将它们指向要运行的代码等方式“启动”其他核心。

同步由操作系统完成。通常，每个处理器为操作系统运行不同的进程，因此操作系统的多线程功能负责决定哪个进程可以访问哪个内存，以及在内存碰撞的情况下该做什么。

I think the questioner probably wants to make a program run faster by having multiple cores work on it in parallel. That's what I would want anyway but all the answers leave me no wiser. However, I think I get this: You can't synchronize different threads down to instruction execution time accuracy. So you can't get 4 cores to do a multiply on four different array elements in parallel to speed up processing by 4:1. Rather, you have to look at your program as comprising major blocks that execute sequentially like

对一些数据做FFT吗 把结果放到一个矩阵中，然后找出它的特征值和特征向量 根据特征值对后者进行排序 用新的数据重复第一步

What you can do is run step 2 on the results of step 1 while running step one in a different core on new data, and running step 3 on the results of step2 in a different core while step 2 is running on the next data and step 1 is running on the data after that. You can do this in Compaq Visual Fortran and Intel Fortran which is an evolution of CVF by writing three separate programs/ subroutines for the three steps and instead of one "calling" the next it calls an API to start its thread. They can share data by using COMMON which will be COMMON data memory to all threads. You have to study the manual till your head hurts and experiment until you get it to work but I have succeeded once at least.

What has been added on every multiprocessing-capable architecture compared to the single-processor variants that came before them are instructions to synchronize between cores. Also, you have instructions to deal with cache coherency, flushing buffers, and similar low-level operations an OS has to deal with. In the case of simultaneous multithreaded architectures like IBM POWER6, IBM Cell, Sun Niagara, and Intel "Hyperthreading", you also tend to see new instructions to prioritize between threads (like setting priorities and explicitly yielding the processor when there is nothing to do).

但是基本的单线程语义是相同的，您只是添加额外的设施来处理与其他核心的同步和通信。