寄存器基本概念
寄存器是CPU内部用来存放数据的一些小型存储区域，用来暂时存放参与运算的数据和运算结果。其实寄存器就是一种常用的时序逻辑电路，但这种时序逻辑电路只包含存储电路。寄存器的存储电路是由锁存器或触发器构成的，因为一个锁存器或触发器能存储1位二进制数，所以由N个锁存器或触发器可以构成N位寄存器。寄存器是中央处理器内的组成部份。寄存器是有限存贮容量的高速存贮部件，它们可用来暂存指令、数据和位址。在中央处理器的控制部件中，包含的寄存器有指令寄存器(IR)和程序计数器(PC)。在中央处理器的算术及逻辑部件中，包含的寄存器有累加器(ACC)。以Intel 80x86 CPU为例，80x86 CPU的寄存器组包括若干个8位、16位和32位寄存器，其中，32位寄存器是从80386 CPU开始才引入的。
寄存器分类
1、数据寄存器
数据寄存器主要用来保存操作数和运算结果等信息，从而节省读取操作数所需占用总线和访问存储器的时间。RAX、RBX、RCX、RDX和EAX、EBX、ECX、EDX以及AX、BX、CX、DX分别称为64位、32位、16位数据寄存器(通用寄存器)。
2、变址寄存器
变址寄存器主要用于存放存储单元在段内的偏移量，用它们可实现多种存储器操作数的寻址方式，为以不同的地址形式访问存储单元提供方便。
变址寄存器不可分割成8位寄存器。作为通用寄存器，也可存储算术逻辑运算的操作数和运算结果。
变址寄存器它们可作一般的存储器指针使用。在字符串操作指令的执行过程中，对它们有特定的要求，而且还具有特殊的功能。
寄存器RSI、RDI和ESI、EDI和SI、DI分别称为64位、32位、16位变址寄存器(Index Register)。
3、指针寄存器
指针寄存器主要用于存放堆栈内存储单元的偏移量，用它们可实现多种存储器操作数的寻址方式，为以不同的地址形式访问存储单元提供方便。
指针寄存器不可分割成8位寄存器。作为通用寄存器，也可存储算术逻辑运算的操作数和运算结果。
寄存器RBP、RSP和EBP、ESP和BP、SP称分别为64位、32位、16位指针寄存器(PointerRegister)。
指令寄存器它们主要用于访问堆栈内的存储单元，并且规定：
（1）BP为基指针(BasePointer)寄存器，用它可直接存取堆栈中的数据；
（2）SP为堆栈指针(StackPointer)寄存器，用它只可访问栈顶。
4、段寄存器
段寄存器是根据内存分段的管理模式而设置的。内存单元的物理地址由段寄存器的值和一个偏移量值组合而成的，这样可用两个较少位数的值组合成一个可访问较大物理空间的内存地址。
CS——代码段寄存器(CodeSegmentRegister)，其值为代码段的段值；
DS——数据段寄存器(DataSegmentRegister)，其值为数据段的段值；
ES——附加段寄存器(ExtraSegmentRegister)，其值为附加数据段的段值；
SS——堆栈段寄存器(StackSegmentRegister)，其值为堆栈段的段值；
FS——附加段寄存器(ExtraSegmentRegister)，其值为附加数据段的段值；
GS——附加段寄存器(ExtraSegmentRegister)，其值为附加数据段的段值。
5、指令指针寄存器
指令指针寄存器是存放下次将要执行的指令在代码段的偏移量。在具有预取指令功能的系统中，下次要执行的指令通常已被预取到指令队列中，除非发生转移情况。所以，在理解它们的功能时，不考虑存在指令队列的情况。
RIP、EIP、IP(Instruction
Pointer)分别为64位、32位、16位指令指针寄存器.
6、标志寄存器
运算结果标志位
进位标志CF(Carry Flag)
进位标志的基本规则是若加法时结果最高位向前有进位或减法时最高位向前有借位，则CF=1，否则CF=0。
奇偶标志PF(Parity Flag)
奇偶标志的基本规则是若结果最低字节中1的个数为偶数，则PF=1，否则PF=0。标志寄存器中除了有状态标志以外，还有3个控制标志，控制标志是由程序根据需要用指令来设置的，以控制某些指令的执行方式。
辅助进位标志AF(Auxiliary Carry Flag)
辅助进位标志也称为半进位标志，它的基本规则是若加法时结果低4位（半个字节）向前有进位或减法时结果低4位向前有借位，则AF=1，否则AF=0。该标志主要由CPU内部使用，用于BCD码调整指令。
零标志ZF(Zero Flag)
零标志的基本规则是若运算结果为0，则ZF=1，否则ZF=0。
符号标志SF(Sign Flag)
符号标志的基本规则是若运算结果为负数，则SF=1，否则SF=0。即SF取结果的最高位。
溢出标志OF(Overflow Flag)
溢出标志的基本规则是溢出时置1，否则置0。即如果带符号数的运算结果超出了补码表示的范围，则OF=1，否则OF=0。
状态控制标志位
状态控制标志位是用来控制CPU操作的，它们要通过专门的指令才能使之发生改变。
追踪标志TF(Trap Flag)
追踪标志用于控制CPU是否进入单步调试方式，当TF=1时，CPU以单步方式执行指令，即在每条指令执行结束后，产生中断1，以便对程序进行检查。特别需要说明的是，Intel 80x86 CPU没有提供直接修改该标志的指令。
中断允许标志IF(Interrupt-enable Flag)
中断标志用于控制CPU是否响应外部可屏蔽中断请求，若IF=1，则允许中断，否则禁止中断。
方向标志DF(Direction Flag)
方向标志在串处理指令中控制信息的方向，若DF=0，则每次串操作后内存地址自动递增，否则自动递减。
32位标志寄存器增加的标志位
I/O特权标志IOPL(I/O Privilege Level)
I/O特权标志用两位二进制位来表示，也称为I/O特权级字段。该字段指定了要求执行I/O指令的特权级。如果当前的特权级别在数值上小于等于IOPL的值，那么，该I/O指令可执行，否则将发生一个保护异常。
嵌套任务标志NT(Nested Task)
嵌套任务标志NT用来控制中断返回指令IRET的执行。具体规定如下：
(1)、当NT=0，用堆栈中保存的值恢复EFLAGS、CS和EIP，执行常规的中断返回操作；
(2)、当NT=1，通过任务转换实现中断返回。
重启动标志RF(Restart Flag)
重启动标志RF用来控制是否接受调试故障。规定：RF=0时，表示“接受”调试故障，否则拒绝之。在成功执行完一条指令后，处理机把RF置为0，当接受到一个非调试故障时，处理机就把它置为1，中国自学编程网整理发布！。
虚拟8086方式标志VM(Virtual 8086 Mode)
如果该标志的值为1，则表示处理机处于虚拟的8086方式下的工作状态，否则，处理机处于一般保护方式下的工作状态。
AL与AH、BL与BH、CL与CH、DL与DH分别对应于AX、BX、CX和DX的低8位与高8位，L 即Low（低）之意，H即High（高）之意。AX、BX、CX、DX、SI、DI、BP和SP分别对应于EAX、EBX、ECX、EDX、ESI、 EDI、EBP和ESP的低16位，EAX、EBX、ECX、EDX、ESI、EDI、EBP和ESP都是32位的。EAX（含AX、AH和AL）、 EBX（含BX、BH和BL）、ECX（含CX、CH和CL）和EDX（含DX、DH和DL）统称为数据寄存器；ESI（含SI）和EDI（含DI）统称为变址寄存器； EBP（含BP）和ESP（含SP）统称为指针寄存器。
在对8/16位寄存器进行操作时，相应的16/32位寄存器的其他位不会受到影响。例如，EAX是一个32位通用寄存器，如果我们对AX进行了访问（即访问了EAX的低16位），那么EAX的高16位并不会改变。同理，我们可以使用AL来对AX的低8位进行访问，使用AH对AX的高8位进行访问，AL被修改时会影响AX，但不会影响AH，反之亦然。
自Intel 起，有14个16比特寄存器。其中四个（AX, BX, CX, DX）是通用目的（尽管每个寄存器都有附加目的；举个例子：只有CX可以被用来当作loop（循环）指令的计数器。）每个寄存器可以被当成两个分开的字节访问（因此BX的高比特可以被当成BH，低比特则可以当成BL）。除了这些寄存器，还有四个区块寄存器（CS、DS、SS、ES）。他们用来产生内存的绝对地址。还有两个指针寄存器（SP是指向堆栈的底部，BP可以用来指向堆栈或内存的其它地方）。两个指针寄存器（SI和DI）可以用来指向数组的内部。最后，有旗标寄存器（包含状态旗标比如进位、溢出、结果为零，等等）。以及IP是用来指向目前运行指令的地址。
8个16位通用寄存器，它们是AX、BX、CX、 DX、SI、DI、BP、SP。
4个16位寄存器又可分割成8个独立的8位寄存器(AX：AH-AL、BX：BH-BL、CX：CH-CL、DX：DH-DL)，每个寄存器都有自己的名称，可独立存取。程序员可利用数据寄存器的这种“可分可合”的特性，灵活地处理字/字
节的信息。
AH累加器(Accumulator)AL
可用于乘、除、输入/输出等操作(在乘除指令中指定用来存放操作数)
BH基地址寄存器(Base Register)BL
在计算存储器地址时，可作为基址寄存器使用。
CH计数寄存器(Count Register)CL
在循环和字符串操作时，要用它来控制循环次数；在位操作中，当移多位时，要用CL来指明移位的位数；
DH数据寄存器(DataRegister)DL
在进行乘、除运算时，它可作为默认的操作数参与运算，也可用于存放I/O的端口地址。在16位CPU中，AX、BX、CX和DX不能作为基址和变址寄存器来存放存储单元的地址，但在32位CPU中，其32位寄存器EAX、EBX、ECX和EDX不仅可传送数据、暂存数据保存算术逻辑运算结果，而且也可作为指针寄存器，所以，这些32位寄存器更具有通用性。
自Intel 80386起，四个通用寄存器（EAX, EBX, ECX, EDX），它们较低的16位分别与原本16位的通用寄存器（AX, BX, CX, DX）重叠共用。指针寄存器（EIP, EBP, ESP, ESI, EDI）。区块寄存器除了原本的（CS、DS、SS、ES），另外新增（FS、GS），但是区块寄存器在32位模式下改做为内存区块的选择子寄存器。旗标寄存器被扩展为32位，较低的16位与原本在16位下的旗标寄存器重叠共用。
8个32位通用寄存器，它们是EAX、EBX、ECX、EDX、ESI、EDI、EBP、ESP。
0xb8884ce2
0xbfffeea4
0xb7ed7000
0xbfffee50
0xbfffee50
0xbfffee78
0xbfffee78
0x804869b '&'main()+9'&'
[ PF SF IF ]
EAX被称为32位累加器
ecx（计数寄存器）
ECX中的C即Count（计数之意）。在许多指令中，ECX、CX、CL被用作计数器。
edx（数据寄存器）
EDX中的D即Data（数据之意）。在进行乘法等运算时，常用EDX与EAX或DX与AX的组合来存放一个4字数或双字数。此外，DX也用来存放I/O端口地址。
ebx（基址寄存器）
EBX中的B即Base（基址之意）。EBX与BX常用来表示内存地址，现在所使用的PC中地址都是较大的整数，一般不会是8位，所以BL就不常使用了。
ESP或SP用来指示堆栈段中的栈顶地址。一般情况下不使用ESP或SP做算术运算。
EBP和BP常用来存放内存地址，它们在默认情况下指向堆栈段中的存储单元。
ESI或SI在串指令中表示源数据串的地址。
EDI或DI在串指令中表示目的数据串的地址。
指令指针EIP、IP(Instruction Pointer)是存放下次将要执行的指令在代码段的偏移量。
eflags（Flags Register）
。标志寄存器也称为程序状态寄存器或状态寄存器。指令指针和标志寄存器不能用作指令的操作数，它们是由CPU直接操纵的。特别地，EIP和EFLAGS的低16位分别由IP和FLAGS标识。
cs(Code Segment Register)代码段寄存器
其值为代码段的段值；
ss(Stack Segment Register)堆栈段寄存器
其值为堆栈段的段值；
ds(Data Segment Register)数据段寄存器
其值为数据段的段值；
es(Extra Segment Register)附加段寄存器
其值为附加数据段的段值；
fs(Extra Segment Register)附加段寄存器
其值为附加数据段的段值；
gs(Extra Segment Register)附加段寄存器
其值为附加数据段的段值。
首先是MMX寄存器（MM0～MM7），它们分别与浮点运算器〈FP0～FP7〉相重叠，所以MMX与浮点运算不可同时使用，必须通过切换选择要使用哪一种。
之后在x86正式导入64位架构后，四个通用寄存器（RAX, RBX, RCX, RDX），它们较低的32位分别与原本32位的通用寄存器（EAX, EBX, ECX, EDX）重叠共用。指针寄存器（RIP, RBP, RSP, RSI, RDI）。以及增加八个通用寄存器（R8～R15）。
在2002年，由于32位特性的长度，x86的架构开始到达某些设计的极限。这个导致要处理大量的信息存储大于4GB会有困难，像是在数据库或是视频编辑上可以发现。
英特尔原本已经决定在64位的世代完全地舍弃x86兼容性，推出新的架构称为IA-64技术作为他的Itanium处理器产品线的基础。IA-64与x86的软件天生不兼容；它使用各种模拟形式来运行x86的软件，不过，以模拟方式来运行的效率十分低下，并且会影响其他程序的运行。
超微主动把32位x86（或称为IA-32）扩充为64位。它以一个称为AMD64的架构出现（在重命名前也称为x86-64），且以这个技术为基础的第一个产品是单核心的Opteron和Athlon 64处理器家族。由于AMD的64位处理器产品线首先进入市场，且微软也不愿意为英代尔和AMD开发两套不同的64位操作系统，英代尔也被迫采纳AMD64指令集且增加某些新的扩充到他们自己的产品，命名为EM64T架构（显然他们不想承认这些指令集是来自它的主要对手），EM64T后来被英代尔正式更名为Intel 64。
4个64位通用寄存器：RAX、RBX、RCX、RDX
4个64位指令寄存器：RSI、RDI、RBP、RSP
0x7fffffffdaa8
0x7fffffffda98
0x7fffffffd9b0
0x7fffffffd9b0
0x7fffffffd9a0
0x7fffffffd9a0
0x7ffff7ad0e80
0x7ffff7dbdfb0
0x7fffffffd710
0x7ffff774d410
0x7fffffffda90
0x400836 '&'main()+8'&'
cs(Code Segment Register)代码段寄存器
其值为代码段的段值；
ss(Stack Segment Register)堆栈段寄存器
其值为堆栈段的段值；
ds(Data Segment Register)数据段寄存器
其值为数据段的段值；
es(Extra Segment Register)附加段寄存器
其值为附加数据段的段值；
fs(Extra Segment Register)附加段寄存器
其值为附加数据段的段值；
gs(Extra Segment Register)附加段寄存器
其值为附加数据段的段值。
Purpose of registers
Although the main registers (with the exception of the instruction pointer) are “general-purpose” in the 32-bit and 64-bit versions of the instruction set and can be used for anything, it was originally envisioned that they be used for the following purposes:
AL/AH/AX/EAX/RAX: Accumulator
BL/BH/BX/EBX/RBX: Base index (for use with arrays)
CL/CH/CX/ECX/RCX: Counter (for use with loops and strings)
DL/DH/DX/EDX/RDX: Extend the precision of the accumulator (e.g. combine 32-bit EAX and EDX for 64-bit integer operations in 32-bit code)
SI/ESI/RSI: Source index for string operations.
DI/EDI/RDI: Destination index for string operations.
SP/ESP/RSP: Stack pointer for top address of the stack.
BP/EBP/RBP: Stack base pointer for holding the address of the current stack frame.
IP/EIP/RIP: Instruction pointer. Holds the program counter, the current instruction address.
Segment registers:
ES: Extra data
FS: Extra data #2
GS: Extra data #3
No particular purposes were envisioned for the other 8 registers available only in 64-bit mode.
寄存器：64bit比32bit有更多的通用寄存器16个，通用寄存器都是64bit长度的，名称也发生了变化，eax－& rax，增加r8-r15, mmx寄存器位宽是一样的，数目变多了，16个，可以参考
函数调用：64bit已经使用通用寄存器来传递参数，其中windows系统是前面四个参数用，linux系统是前面6个参数，剩下的通过栈来传递，32bit windows和linux所有参数都是通过栈来传递的
指令集：32bit和64bit的指令集是一样的。
寄存器：arm64有32个64bit长度的通用寄存器x0～x30，sp，可以只使用其中的32bit w0～w30，arm32只有16个32bit的通用寄存器r0~r12, lr, pc, sp.
arm64有32个128bitSIMD寄存器v0～v31，arm32有16个128bitSIMD寄存器Q0～Q15，又可细分为32个64bitSIMD寄存器D0～D31
函数调用：arm64前面8个参数都是通过寄存器来传递x0～x7， arm32前面4个参数通过寄存器来传递r0～r3，其他通过栈传递
指令集：arm64和arm32是两套不同的指令集，尤其是SIMD指令集完全不同。
多媒体指令集
1. 精简指令集（RISC）:
多媒体加速扩展指令集 (MAX)
&&&可视化指令集 (VIS)
&&&&&&MDMX、MIPS-3D
&&&&&动态视频指令集 (MVI)
&&&&&&NEON
2. 复杂指令集（CISC）:
x86/x86-64
MMX · 3DNow! · 流式单指令流多数据流功能扩展指令集 (SSE) · SSE2 · SSE3 · 扩展SSE3 (SSSE3) · SSE4 · SSE4a · SSE5 → XOP、F16C/CVT16、FMA(包括FMA4、FMA3) · 高级加密标准指令集 (AES) · 高级矢量扩展指令集 (AVX、AVX1.1、AVX2、AVX-512) · 位操作指令集 (ABM、BMI1、BMI2、TBM)
x86 CPU所有的寄存器种类
X86-64寄存器和栈帧
没有更多推荐了，声明：本文为《程序员》原创文章，未经允许不得转载，更多精彩文章请订阅2016年《程序员》 作者：陈康贤（），阿里巴巴技术专家，花名龙隆，著有《大型分布式网站架构设计与实践》一书，擅长Java Web程序设计，长期在淘宝分布式环境下耳濡目染，目前关注于Java高性能程序设计及性能优化，博客地址。 责编：钱曙光，关注架构和算法领域，寻求报道或者投稿请发邮件，另有「CSDN 高级架构师群」，内有诸多知名互联网公司的大牛架构师，欢迎架构师加微信qshuguang2008申请入群，备注姓名+公司+职位。 推荐：
看完文章有问题？欢迎参加陈康贤老师问答活动()
相对于传统商业模式来说，电子商务带来的变革使人们足不出户便能享受到购物的乐趣，十几二十年前，很难想象几亿中国人能够在双十一一天产生几百亿的消费。同时，大流量带来了高并发的问题，其中针对技术人员尤为突出的是高并发系统的设计，它与普通系统设计的区别在于既要保障系统的可用性、可扩展性，又要兼顾数据一致性，还要处理多线程同步的问题。任何细微问题，都有可能在高并发环境下被无限的放大，直至系统宕机。操作原子性原子操作是指不可分割的操作，它要么执行成功，要么执行失败，不会产生中间状态，在多线程程序中，原子操作是一个非常重要的概念，它常常用来实现一些数据同步机制，具体的例子如Java的原子变量、数据库的事务等。同时，原子操作也是常见多线程程序Bug的源头，并发相关的问题对于测试来说，并不是每次都能够重现，因此处理起来十分棘手。比如，大部分站点都有数据count统计的需求，一种实现方式如下：public class Count {
public int count = 0;
static class Job implements Runnable{
private CountDownLatch countD
private Count count;
public Job(Count count,CountDownLatch countDown){
this.count = count;
this.countDown = countD
public void run() {
count.count++;
countDown.countDown();
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDown = new CountDownLatch(1500);
Count count = new Count();
ExecutorService ex = Executors.newFixedThreadPool(5);
for(int i = 0; i & 1500; i ++){
ex.execute(new Job(count,countDown));
countDown.await();
System.out.println(count.count);
ex.shutdown();
}Count对象中有一个count的int类型属性，Job负责每次给Count对象的count属性做++操作，创建一个有包含5个线程的线程池，新建一个count共享对象，将对象的引用传递给每一个线程，线程负责给对象的count属性++。乍看程序的逻辑没啥问题，但运行的结果却总是不正确，是由于问题出在count.count++上，这里边涉及到多线程同步的问题，此外，其中很重要的一点是count.count++并不是原子操作，当Java代码最终被编译成字节码时，run()方法会被编译成这几条指令[1]：public void run();
//将int型1压入栈顶
//将栈顶两int型数值相加,并将结果压入栈顶
invokevirtual
}要完成count.count++操作，首先需要将count.count与1入栈，然后再相加，最后再将结果覆盖count.count变量。而在多线程情况下，有可能执行完getfield指令之后，其他线程此时执行putfield指令，给count.count变量赋值，这样，栈顶的count.count变量值与它实际值就存在不一致的情况，接着执行完iadd指令后，再将结果赋值回去，就会出现错误。JDK5.0以后开始提供Atomic Class，支持CAS(CompareAndSet)等一系列原子操作，来帮助我们简化多线程程序设计，要避免上述情况的发生，可以使用JDK提供的原子变量：public class AtomicCount {
public AtomicInteger count = new AtomicInteger(0);
static class Job implements Runnable{
private AtomicCount count;
private CountDownLatch countD
public Job(AtomicCount count,CountDownLatch
countDown){
this.count = count;
this.countDown = countD
public void run() {
boolean isSuccess = false;
while(!isSuccess){
int countValue = count.count.get();
isSuccess = count.count.
compareAndSet(countValue, countValue + 1);
countDown.countDown();
public static void main(String[] args)
throws InterruptedException {
}通过AtomicInteger的compareAndSet方法，只有当假定的count值与实际的count值相同时，才将加1后的值赋值回去，避免多线程环境下变量值被并发修改而导致的数据紊乱。通过查看AtomicInteger的compareAndSet方法的实现，可以发现它通过调用Unsafe对象的native方法compareAndSwapInt，来完成原子操作[2]：public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}而native方法compareAndSwapInt在Linux下的JDK的实现如下[3]：UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
UnsafeWrapper("Unsafe_CompareAndSwapInt");
oop p = JNIHandles::resolve(obj);
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
return (jint)(Atomic::cmpxchg(x, addr, e)) ==
UNSAFE_ENDUnsafe_CompareAndSwapInt最终通过Atomic::cmpxchg(x, addr, e)来实现原子操作，而Atomic::cmpxchg在x86处理器架构下的Linux下的JDK实现如[4]：inline jint Atomic::cmpxchg(jint exchange_value, volatile jint* dest, jint compare_value){
int mp = os::is_MP();
__asm__ volatile(LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
: "=a" (exchange_value)
: "r" (exchange_value),"a" (compare_value),"r" (dest),"r" (mp)
: "cc", "memory");
return exchange_
}通过os::is_MP()判断当前系统是否为多核系统，如果是，在执行cmpxchgl指令前，先通过LOCK_IF_MP宏定义将CPU总线锁定，这样同一芯片上其他处理器就暂时不能通过总线访问内存，保证了该指令在多处理器环境下的原子性。而cmpxchgl指令，则先判断eax寄存器中的compare_value变量值是否与exchange_value变量的值相等，如果相等，执行exchange_value与dest的交换操作，并将exchange_value的值返回。其中，“=a”中=表示输出，而“a”表示eax寄存器，变量前的“r”表示任意寄存器，“cc”表示告诉编译器cmpxchgl指令的执行，将影响到标志寄存器，而“memory”则是告诉编译器该指令需要重新从内存中读取变量的最新值，而非使用寄存器中已经存在的拷贝。最终，JDK通过CPU的cmpxchgl指令的支持，实现AtomicInteger的CAS操作的原子性。另一种情况便是数据库的事务操作，数据库事务具有ACID属性，即原子性（Atomic）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability），为针对数据库的一系列操作提供了一种从失败状态恢复到正常状态的方法，使数据库在异常状态下也能够保持数据的一致性，且面对并发访问时，数据库能够提供一种隔离方法，避免彼此间的操作互相干扰。数据库事务由具体的DBMS系统来保障操作的原子性，同一个事务当中，如果有某个操作执行失败，则事务当中的所有操作都需要进行回滚，回到事务执行前的状态。导致事务失败的原因有很多，可能是因为修改不符合表的约束规则，也有可能是网络异常，甚至是存储介质故障等，而一旦事务失败，则需要对所有已作出的修改操作进行还原，使数据库的状态恢复到事务执行前的状态，以保障数据的一致性，使修改操作要么全部成功、要么全部失败，避免存在中间状态[5]。为了实现数据库状态的恢复，DBMS系统通常需要维护事务日志以追踪事务中所有影响数据库数据的操作，以便执行失败时进行事务的回滚。以MySQL的innodb存储引擎为例，innodb存储引擎通过预写事务日志[6]的方式，来保障事务的原子性、一致性以及持久性。它包含redo日志和undo日志，redo日志在系统需要的时候，对事务操作进行重做，如当系统宕机重启后，能够对内存中还没有持久化到磁盘的数据进行恢复，而undo日志，则能够在事务执行失败的时候，利用这些undo信息，将数据还原到事务执行前的状态。事务日志可以提高事务执行的效率，存储引擎只需要将修改行为持久到事务日志当中，便可以只对该数据在内存中的拷贝进行修改，而不需要每次修改都将数据回写到磁盘。这样做的好处是，日志写入是一小块区域的顺序I/O，而数据库数据的磁盘回写则是随机I/O，磁头需要不停地移动来寻找需要更新数据的位置，无疑效率更低，通过事务日志的持久化，既保障了数据存储的可靠性，又提高了数据写入的效率。多线程同步同步的意思就是协同步调，按照预定的先后次序来执行，多线程同步指的是线程之间执行的顺序，多个线程并发既访问和操作同一数据，并且执行的结果与访问或者操作的次序有关，表示线程间存在竞争关系，为了避免这种竞争导致错误发生，我们需要保证一段时间内只有一个线程能够操作共享的变量或者数据，而为了实现这种保证，就需要进行一定形式的线程同步。对于线程中操作共享变量或者数据的那段代码，我们称为临界代码段。对于临界代码段来说，有一个简单易用的工具——锁，通过锁的保护，可以避免线程间的竞争关系，即一个线程在进入临界代码段之前，必须先获得锁，而当其退出临界代码段的时候，则释放锁给其他线程。还是前面Count计数的例子，通过在Java中使用synchronized关键字和锁，实现线程间的同步：public void run() {
synchronized(count){
count.count++;
}通过synchronized，能够保证同一时刻只有一个线程修改count对象。synchronized关键字在进过编译之后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令：……
monitorenter
monitorexit
……加入关键字后，run()方法反编译成的字节码如上所示，monitorenter和monitorexit这两个字节码都需要一个引用类型的参数，来指明锁定和解锁的对象，如果synchronized明确指定了对象参数，那锁的对象便是这个传入的参数，假如没有明确指定，则根据synchronized修饰的是实例方法还是类方法，找到对应的对象实例或者对应类的Class对象来作为锁对象。在执行monitorenter指令时，首先要尝试获取对象的锁，如果这个对象没有被锁定，或者当前线程已经拥有了该对象的锁，则将锁的计数器加1，相应的，在执行monitorexit指令时，锁的计数器将会减1，当计数器为0时，表示锁被释放。如果获取对象的锁失败了，则当前线程需要阻塞等待，直到对象的锁被释放为止。另一种方式是使用ReentrantLock锁，来实现线程间的同步。在Count对象中加入ReentrantLock的实例：private final ReentrantLock lock = new ReentrantLock();然后在count.count++之前加锁，并且，++操作完成之后，释放锁给其他线程：count.lock.lock();
count.count++;
count.lock.unlock();这样，对于count.count变量的操作便被串行化了，避免了线程间的竞争。相对于synchronized而言，使用ReentrantLock的好处是，ReentrantLock的等待是可以中断的，通过tryLock(timeout, unit)，可以尝试获得锁，并且指定等待的时间。另一个特性是可以在构造ReentrantLock的时候使用公平锁，公平锁指的是多个线程在等待同一个锁时，必须按照申请锁的先后顺序来依次获得，synchronized中的锁是非公平的，默认情况下ReentrantLock也是非公平的，但是可以在构造函数中指定使用公平锁。对于ReentrantLock来说，还有一个十分实用的特性，它可以同时绑定多个Condition条件，以实现更精细化的同步控制：class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull
= lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr,
public void put(Object x) throws InterruptedException {
lock.lock();
while (count == items.length)
notFull.await();
items[putptr] =
if (++putptr == items.length) putptr = 0;
notEmpty.signal();
} finally {
lock.unlock();
public Object take() throws InterruptedException {
lock.lock();
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
notFull.signal();
} finally {
lock.unlock();
}这是Oracle官方文档中所提供的关于Condition使用的一个经典案例—有界缓冲区[7]。notFull（非满）和notEmpty（非空）两个条件与锁lock相关联，当缓冲区当前处于已满状态的时候，notFull条件await，执行put操作的当前线程阻塞，并且释放当前已获得的锁，直到take操作执行，notFull条件signal，等待的线程被唤醒，等待的线程需要重新获得lock的锁，才能从await返回，而当缓冲区为空的时候，notEmpty条件await，执行take操作的当前线程阻塞，并且释放当前已经获得的锁，直到put操作执行，notEmpty条件signal，执行take操作的线程才能够被唤醒，并且需要重新获得lock的锁，才能够从await返回。数据一致性分布式系统常常通过数据的复制来提高系统的可靠性和容错性，并且将数据的副本存放到不同的机器上，由于多个副本的存在，使得维护副本一致性的代价很高。因此，许多分布式系统都采用弱一致性或者是最终一致性，来提高系统的性能和吞吐能力，这样不同的一致性模型也相继被提出。强一致性要求无论数据的更新操作是在哪个副本上执行，之后所有的读操作都要能够获取到更新的最新数据。对于单副本的数据来说，读和写都是在同一份数据上执行，容易保证强一致性，但对于多副本数据来说，若想保障强一致性，就需要等待各个副本的写入操作都执行完毕，才能提供数据的读取，否则就有可能数据不一致，这种情况需要通过分布式事务来保证操作的原子性，并且外界无法读到系统的中间状态。
弱一致性指的是系统的某个数据被更新后，后续对该数据的读取操作，取到的可能是更新前的值，也可能是更新后的值，全部用户完全读取到更新后的数据，需要经过一段时间，这段时间称作“不一致性窗口”。
最终一致性是弱一致性的一种特殊形式，这种情况下系统保证用户最终能够读取到某个操作对系统的更新，“不一致性窗口”的时间依赖于网络的延迟、系统的负载以及副本的个数。
分布式系统中采用最终一致性的例子很多，如MySQL数据库的主/从数据同步，ZooKeeper的Leader Election和Atomic Broadcas等。系统可扩展性系统的可扩展性也称为可伸缩性，是一种对软件系统计算处理能力的评价指标，高可扩展性意味着系统只要经过很少的改动，甚至只需要添加硬件设备，便能够实现整个系统处理能力的线性增长。单台机器硬件受制于科技水平的发展，短时间内的升级空间是有限的，因此很容易达到瓶颈，且随着性能的提升，成本也呈指数级升高，因此可扩展性更加侧重于系统的水平扩展。大型分布式系统常常通过大量廉价的PC服务器，来达到原本需要小型机甚至大型机的同等处理能力。进行系统扩展的时候，只需要增加相应的机器，便能够使性能线性平滑提升，达到硬件升级同等的效果，并且不会受制于硬件的技术水平。水平扩展相对于硬件的垂直扩展来说，对于软件设计的能力要求更高，系统设计更复杂，但是却能够使系统处理能力几乎可以无限制扩展。系统的可扩展性也会受到一些因素的制约，CAP理论指出，系统的一致性、可用性和可扩展性这三个要素，对于分布式系统来说，很难同时满足的，因此，在系统设计的时候，往往得做一些取舍。某些情况下，通过放宽对于一致性的严格要求，以使得系统更易于扩展，可靠性更高。下面将介绍一个典型的案例，通过在数据一致性、系统可用性以及系统可扩展性之间找到平衡点，来完成瞬间高并发场景下的系统设计。并发减库存大部分电商网站都会有这样一个场景——减库存。正常情况下，对于普通的商品售卖来说，同时参与购买的人数不是很多，因此，问题并不那么明显，但是，对于像秒杀活动，低价爆款商品，抽奖活动这种并发数极高的场景来说，情况便显得不同了。比如在活动开始的瞬间，用户的下单和减库存请求将呈爆炸式增长，瞬间的qps可达平时的几千倍，这将对系统的设计和实现带来极大的挑战。首先要解决的问题，便是杜绝网络投机者使用工具参与秒杀导致的不公平竞争行为，让竞争变得公平。而防止机器请求最原始最简单也是最有效的方式，便是采用图像验证码，用户必须手工输入图片上的字符，才能够进行后续操作，当然，随着技术的发展，简单图像也能够进行识别，因此，验证码技术也在不断演进，为了防止图像识别技术识别验证码字符，可以采用问答式的验证码，如“1+1=？”这样，即便是识别验证码上的字符，也无法自动识别答案。当然，验证码并非是一个完美的解决方案，它会导致系统的易用性降低，用户体验因此而下降。其次要解决的便是数据一致性的问题，对于高并发访问的浏览型系统来说，单机数据库如不进行扩展，往往很难支撑，因此，常常会采用分库技术，来提高数据库的并发能力，并且通过使用分布式缓存技术，将磁盘磁头的机械运动，转化为内存的高低电平，以降低数据库的压力，加快后端的响应速度，响应得越快，线程释放也越快，能够支持的单位时间内的查询数也越高，并发的处理能力就越强。使用缓存和分库技术，吞吐量的确是上去了，带来的问题便是，跨数据库或者是分布式缓存与数据库之间，难以进行事务操作，由于下单和减库存这两个操作不在同一个事务当中，可能导致的问题便是，有可能下单成功，库存减失败，导致“超卖”的现象发生，或者是下单失败，而减库存成功，而导致“少卖”的现象，并且，在超高并发的情况下，导致这种失败的概率较往常更高，如图1所示。图1 “超卖”和“少卖”现象为了避免数据不一致的情况发生，并且，保证前端页面能够在高并发情况下正常浏览，可以采用实际库存和浏览库存分离的方式。由于前端页面验证码以及下单系统的限流保护，因此，真正到达后端系统下单的流量并没有前端浏览系统的流量大，因此，可以将真实的库存保存在数据库，而前端浏览的库存信息存放于缓存，这样，数据库下单与减库存两个动作，可以在同一个事务当中执行，避免出现数据不一致的情况，库存更新完毕以后，再将数据库中数据同步到缓存。实际库存与浏览库存分离之后，虽解决了数据不一致的问题，但这一措施将引入新的问题。商业数据库如Oracle由于扩展成本太高，大部分互联网企业转而选用开源的MySQL数据库，MySQL根据存储引擎的不同，采用不同的锁策略。MyISAM存储引擎对写操作采用的是表锁策略，当一个用户对表进行写操作时，该用户会获得一个写锁，写锁会禁止其他用户的写入操作。InnoDB存储引擎采用的则是行所策略，只有在对同一行进行写入操作的时候，锁机制才会生效。显而易见，InnoDB更适合于高并发写入的场景。那么，采用InnoDB存储引擎，对于高并发下单减库存的场景，会带来什么问题呢？每个用户下单之后，需要对库存信息进行更新，对于参与秒杀的热门商品来说，大部分更新请求最终都会落到少量的几条记录上，而行锁的存在，使得线程之间需要进行锁的争夺，一个线程获得行锁以后，其他并发线程就需要等待它处理完成，这样系统将无法利用多线程并发执行的优势，且随着并发数的增加，等待的线程会越来越多，rt急剧飚升，最终导致可用连接数被占满，数据库拒绝服务。既然记录的行锁会导致无法并发利用资源的问题，那么，可以通过将一行库存拆分成多行，便可以解除行锁导致的并发资源利用的问题。当然，下单减库存操作最终路由到哪一条记录，可以采用多种策略，如根据用户ID取模、随机等，总的库存通过SUM函数进行汇总，再同步到缓存，给前端页面做展现，以降低数据库的压力。图2 库存记录拆分，sum取总数当然，这样也会导致另外一些问题，当总库存大于0的时候，前端的下单请求，可能刚好被路由到一条库存为0的记录，导致减库存失败，而实际此时还有其他记录的库存不为0。【参考资料】字节码并非最终执行的汇编指令，但是已经足够用来说明原子性问题
该段代码来自OpenJDK6的源码，源码下载地址为，路径为jdk/src/share/classes/java/util/concurrent/atomic/AtomicInteger.java
该段代码来自OpenJDK6的源码，代码的路径为hotspot/src/share/vm/prims/unsafe.cpp
该段代码来自OpenJDK6的源码，代码的路径为hotspot/src/os_cpu/linux_x86/vm/atomic_linux_x86.inline.hpp
关于数据库事务的介绍可参考数据库事务
在写入数据之前，先将数据操作写入日志，称为预写日志
Oracle关于Condition介绍的Java Doc地址。
深入理解分布式事务,高并发下分布式事务的解决方案
电商那些年，我摸爬打滚出的高并发架构实战精髓(续)
高并发下的下单功能设计
实现高性能高并发的计数器功能
大数据量高并发访问SQL优化方法
没有更多推荐了，}