转自：http://www.cnblogs.com/fanzhidongyzby/p/4098546.html

服务器端编程经常需要构造高性能的IO模型，常见的IO模型有四种：

（1）同步阻塞IO（Blocking IO）：即传统的IO模型。

（2）同步非阻塞IO（Non-blocking IO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（New IO）库。

（3）IO多路复用（IO Multiplexing）：即经典的Reactor设计模式，有时也称为异步阻塞IO，Java中的Selector和Linux中的epoll都是这种模型。

（4）异步IO（Asynchronous IO）：即经典的Proactor设计模式，也称为异步非阻塞IO。

同步和异步的概念描述的是用户线程与内核的交互方式：同步是指用户线程发起IO请求后需要等待或者轮询内核IO操作完成后才能继续执行；而异步是指用户线程发起IO请求后仍继续执行，当内核IO操作完成后会通知用户线程，或者调用用户线程注册的回调函数。

阻塞和非阻塞的概念描述的是用户线程调用内核IO操作的方式：阻塞是指IO操作需要彻底完成后才返回到用户空间；而非阻塞是指IO操作被调用后立即返回给用户一个状态值，无需等到IO操作彻底完成。

另外，Richard Stevens 在《Unix 网络编程》卷1中提到的基于信号驱动的IO（Signal Driven IO）模型，由于该模型并不常用，本文不作涉及。接下来，我们详细分析四种常见的IO模型的实现原理。为了方便描述，我们统一使用IO的读操作作为示例。

一、同步阻塞IO

同步阻塞IO模型是最简单的IO模型，用户线程在内核进行IO操作时被阻塞。

图1 同步阻塞IO

如图1所示，用户线程通过系统调用read发起IO读操作，由用户空间转到内核空间。内核等到数据包到达后，然后将接收的数据拷贝到用户空间，完成read操作。

用户线程使用同步阻塞IO模型的伪代码描述为：

即用户需要等待read将socket中的数据读取到buffer后，才继续处理接收的数据。整个IO请求的过程中，用户线程是被阻塞的，这导致用户在发起IO请求时，不能做任何事情，对CPU的资源利用率不够。

二、同步非阻塞IO

同步非阻塞IO是在同步阻塞IO的基础上，将socket设置为NONBLOCK。这样做用户线程可以在发起IO请求后可以立即返回。

图2 同步非阻塞IO

如图2所示，由于socket是非阻塞的方式，因此用户线程发起IO请求时立即返回。但并未读取到任何数据，用户线程需要不断地发起IO请求，直到数据到达后，才真正读取到数据，继续执行。

用户线程使用同步非阻塞IO模型的伪代码描述为：

即 用户需要不断地调用read，尝试读取socket中的数据，直到读取成功后，才继续处理接收的数据。整个IO请求的过程中，虽然用户线程每次发起IO请 求后可以立即返回，但是为了等到数据，仍需要不断地轮询、重复请求，消耗了大量的CPU的资源。一般很少直接使用这种模型，而是在其他IO模型中使用非阻 塞IO这一特性。

三、IO多路复用

IO多路复用模型是建立在内核提供的多路分离函数select基础之上的，使用select函数可以避免同步非阻塞IO模型中轮询等待的问题。

图3 多路分离函数select

如图3所示，用户首先将需要进行IO操作的socket添加到select中，然后阻塞等待select系统调用返回。当数据到达时，socket被激活，select函数返回。用户线程正式发起read请求，读取数据并继续执行。

从 流程上来看，使用select函数进行IO请求和同步阻塞模型没有太大的区别，甚至还多了添加监视socket，以及调用select函数的额外操作，效 率更差。但是，使用select以后最大的优势是用户可以在一个线程内同时处理多个socket的IO请求。用户可以注册多个socket，然后不断地调 用select读取被激活的socket，即可达到在同一个线程内同时处理多个IO请求的目的。而在同步阻塞模型中，必须通过多线程的方式才能达到这个目的。

用户线程使用select函数的伪代码描述为：

其中while循环前将socket添加到select监视中，然后在while内一直调用select获取被激活的socket，一旦socket可读，便调用read函数将socket中的数据读取出来。

然 而，使用select函数的优点并不仅限于此。虽然上述方式允许单线程内处理多个IO请求，但是每个IO请求的过程还是阻塞的（在select函数上阻 塞），平均时间甚至比同步阻塞IO模型还要长。如果用户线程只注册自己感兴趣的socket或者IO请求，然后去做自己的事情，等到数据到来时再进行处 理，则可以提高CPU的利用率。

IO多路复用模型使用了Reactor设计模式实现了这一机制。

图4 Reactor设计模式

如 图4所示，EventHandler抽象类表示IO事件处理器，它拥有IO文件句柄Handle（通过get_handle获取），以及对Handle的 操作handle_event（读/写等）。继承于EventHandler的子类可以对事件处理器的行为进行定制。Reactor类用于管理 EventHandler（注册、删除等），并使用handle_events实现事件循环，不断调用同步事件多路分离器（一般是内核）的多路分离函数 select，只要某个文件句柄被激活（可读/写等），select就返回（阻塞），handle_events就会调用与文件句柄关联的事件处理器的 handle_event进行相关操作。

图5 IO多路复用

如 图5所示，通过Reactor的方式，可以将用户线程轮询IO操作状态的工作统一交给handle_events事件循环进行处理。用户线程注册事件处理 器之后可以继续执行做其他的工作（异步），而Reactor线程负责调用内核的select函数检查socket状态。当有socket被激活时，则通知 相应的用户线程（或执行用户线程的回调函数），执行handle_event进行数据读取、处理的工作。由于select函数是阻塞的，因此多路IO复用 模型也被称为异步阻塞IO模型。注意，这里的所说的阻塞是指select函数执行时线程被阻塞，而不是指socket。一般在使用IO多路复用模型 时，socket都是设置为NONBLOCK的，不过这并不会产生影响，因为用户发起IO请求时，数据已经到达了，用户线程一定不会被阻塞。

用户线程使用IO多路复用模型的伪代码描述为：

用户需要重写EventHandler的handle_event函数进行读取数据、处理数据的工作，用户线程只需要将自己的EventHandler注册到Reactor即可。Reactor中handle_events事件循环的伪代码大致如下。

事件循环不断地调用select获取被激活的socket，然后根据获取socket对应的EventHandler，执行器handle_event函数即可。

IO多路复用是最常使用的IO模型，但是其异步程度还不够“彻底”，因为它使用了会阻塞线程的select系统调用。因此IO多路复用只能称为异步阻塞IO，而非真正的异步IO。

四、异步IO

“真 正”的异步IO需要操作系统更强的支持。在IO多路复用模型中，事件循环将文件句柄的状态事件通知给用户线程，由用户线程自行读取数据、处理数据。而在异 步IO模型中，当用户线程收到通知时，数据已经被内核读取完毕，并放在了用户线程指定的缓冲区内，内核在IO完成后通知用户线程直接使用即可。

异步IO模型使用了Proactor设计模式实现了这一机制。

图6 Proactor设计模式

如 图6，Proactor模式和Reactor模式在结构上比较相似，不过在用户（Client）使用方式上差别较大。Reactor模式中，用户线程通过 向Reactor对象注册感兴趣的事件监听，然后事件触发时调用事件处理函数。而Proactor模式中，用户线程将 AsynchronousOperation（读/写等）、Proactor以及操作完成时的CompletionHandler注册到 AsynchronousOperationProcessor。AsynchronousOperationProcessor使用Facade模式提 供了一组异步操作API（读/写等）供用户使用，当用户线程调用异步API后，便继续执行自己的任务。 AsynchronousOperationProcessor 会开启独立的内核线程执行异步操作，实现真正的异步。当异步IO操作完成 时，AsynchronousOperationProcessor将用户线程与AsynchronousOperation一起注册的Proactor 和CompletionHandler取出，然后将CompletionHandler与IO操作的结果数据一起转发给 Proactor，Proactor负责回调每一个异步操作的事件完成处理函数handle_event。虽然Proactor模式中每个异步操作都可以 绑定一个Proactor对象，但是一般在操作系统中，Proactor被实现为Singleton模式，以便于集中化分发操作完成事件。

图7 异步IO

如 图7所示，异步IO模型中，用户线程直接使用内核提供的异步IO API发起read请求，且发起后立即返回，继续执行用户线程代码。不过此时用户线程已 经将调用的AsynchronousOperation和CompletionHandler注册到内核，然后操作系统开启独立的内核线程去处理IO操 作。当read请求的数据到达时，由内核负责读取socket中的数据，并写入用户指定的缓冲区中。最后内核将read的数据和用户线程注册的 CompletionHandler分发给内部Proactor，Proactor将IO完成的信息通知给用户线程（一般通过调用用户线程注册的完成事件 处理函数），完成异步IO。

用户线程使用异步IO模型的伪代码描述为：

用户需要重写CompletionHandler的handle_event函数进行处理数据的工作，参数buffer表示Proactor已经准备好的数据，用户线程直接调用内核提供的异步IO API，并将重写的CompletionHandler注册即可。

相 比于IO多路复用模型，异步IO并不十分常用，不少高性能并发服务程序使用IO多路复用模型+多线程任务处理的架构基本可以满足需求。况且目前操作系统对 异步IO的支持并非特别完善，更多的是采用IO多路复用模型模拟异步IO的方式（IO事件触发时不直接通知用户线程，而是将数据读写完毕后放到用户指定的 缓冲区中）。Java7之后已经支持了异步IO，感兴趣的读者可以尝试使用。

本文从基本概念、工作流程和代码示 例三个层次简要描述了常见的四种高性能IO模型的结构和原理，理清了同步、异步、阻塞、非阻塞这些容易混淆的概念。通过对高性能IO模型的理解，可以在服 务端程序的开发中选择更符合实际业务特点的IO模型，提高服务质量。希望本文对你有所帮助。

相似的：
http://www.cnblogs.com/nufangrensheng/p/3588690.html
http://www.ibm.com/developerworks/cn/linux/l-async/

HotSpot Glossary of Terms

A work in progress, especially as the HotSpot VM evolves. But a place to put definitions of things so we only have to define them once. There are empty entries (marked TBD for "to be defined") because we think of things that we need to define faster than we think of good definitions.

adaptive spinning

An optimization technique whereby a thread spins waiting for a change-of-state to occur (typically a flag that represents some event has occurred - such as the release of a lock) rather than just blocking until notified that the change has occurred. The "adaptive" part comes from the policy decisions that control how long the thread will spin until eventually deciding to block.

biased locking

An optimization in the VM that leaves an object as logically locked by a given thread even after the thread has released the lock. The premise is that if the thread subsequently reacquires the lock (as often happens), then reacquisition can be achieved at very low cost. If a different thread tries to acquire a biased lock then the bias must be revoked from the current bias owner.

block start table

A table that shows, for a region of the heap, where the object starts that comes on to this region from lower addresees. Used, for example, with thecard table variant of the remembered set.

bootstrap classloader

The logical classloader that has responsibility for loading the classes (and resources) that are found in the boot-classpath - typically the core Java platform classes. Typically implemented as part of the VM, by historical convention the bootstrap classloader is represented by NULL at the Java API level.

bytecode verification

A step in the linking process of a class where the methods bytecodes are analyzed to ensure type-safety.

C1 compiler

Fast, lightly optimizing bytecode compiler. Performs some value numbering, inlining, and class analysis. Uses a simple CFG-oriented SSA "high" IR, a machine-oriented "low" IR, a linear scan register allocation, and a template-style code generator.

C2 compiler

Highly optimizing bytecode compiler, also known as 'opto'. Uses a "sea of nodes" SSA "ideal" IR, which lowers to a machine-specific IR of the same kind. Has a graph-coloring register allocator; colors all machine state, including local, global, and argument registers and stack. Optimizations include global value numbering, conditional constant type propagation, constant folding, global code motion, algebraic identities, method inlining (aggressive, optimistic, and/or multi-morphic), intrinsic replacement, loop transformations (unswitching, unrolling), array range check elimination.

card table

A kind of remembered set that records where oops have changed in a generation.

class data sharing

A startup optimization that records the in-memory form of some classes, so that that form can be mapped into memory by a subsequent run of the virtual machine, rather than loading those classes from their class files.

class hierachy analysis

Also known as 'CHA'. Analysis of the class tree used by a compiler to determine if the receiver at a virtual call site has a single implementor. If so, the callee can be inlined or the compiler can employ some other static call mechanism.

code cache

A special heap that holds compiled code. These objects are not relocated by the GC, but may contain oops, which serve as GC roots.

compaction

A garbage collection technique that results in live objects occupying a dense portion of the virtual address space, and available space in another portion of the address space. Cf. free list.

concurrency

Concurrency, or more specifically concurrent programming, is the logical simultaneous execution of multiple instruction streams. If multiple processors are available then the logical simultaneity can be physical simultaneity - this is known as 'parallelism'

concurrent garbage collection

A garbage collection algorithm that does most (if not all) of its work while the Java application threads are still running.

copying garbage collection

A garbage collection algorithm that moves objects during the collection.

deoptimization

The process of converting an compiled (or more optimized) stack frame into an interpreted (or less optimized) stack frame. Also describes the discarding of an nmethod whose dependencies (or other assumptions) have been broken. Deoptimized nmethods are typically recompiled to adapt to changing application behavior. Example: A compiler initially assumes a reference value is never null, and tests for it using a trapping memory access. Later on, the application uses null values, and the method is deoptimized and recompiled to use an explicit test-and-branch idiom to detect such nulls.

dependency

An optimistic assumption associated with an nmethod, which allowed the compiler to emit improved code into the nmethod. Example: A given class has no subclasses, which simplifies method dispatch and type testing. The loading of new classes (or replacement of old classes) can cause dependencies to become false, which requires dependent nmethods to be discarded and activations of those nmethods to be deoptimized.

eden

A part of the Java object heap where object can be created efficiently.

free list

A storage management technique in which unused parts of the Java object heap are chained one to the next, rather than having all of the unused part of the heap in a single block.

garbage collection

The automatic management of storage.

garbage collection root

A pointer into the Java object heap from outside the heap. These come up, e.g., from static fields of classes, local references in activation frames, etc.

GC map

A description emitted by the JIT (C1 or C2) of the locations of oops in registers or on stack in a compiled stack frame. Each code location which might execute a safepoint has an associated GC map. The GC knows how to parse a frame from a stack, to request a GC map from a frame's nmethod, and to unpack the GC map and manage the indicated oops within the stack frame.

generational garbage collection

A storage management technique that separates objects expected to be referenced for different lengths of time into different regions of the heap, so that different algorithms can be applied to the collection of those regions.

handle

A memory word containing an oop. The word is known to the GC, as a root reference. C/C++ code generally refers to oops indirectly via handles, to enable the GC to find and manage its root set more easily. Whenever C/C++ code blocks in a safepoint, the GC may change any oop stored in a handle. Handles are either 'local' (thread-specific, subject to a stack discipline though not necessarily on the thread stack) or global (long-lived and explicitly deallocated). There are a number of handle implementations throughout the VM, and the GC knows about them all.

hot lock

A lock that is highly contended.

interpreter

A VM module which implements method calls by individually executing bytecodes. The interpreter has a limited set of highly stylized stack frame layouts and register usage patterns, which it uses for all method activations. The Hotspot VM generates its own interpreter at start-up time.

JIT compilers

An on-line compiler which generates code for an application (or class library) during execution of the application itself. ("JIT" stands for "just in time".) A JIT compiler may create machine code shortly before the first invocation of a Java method. Hotspot compilers usually allow the interpreter ample time to "warm up" Java methods, by executing them thousands of times. This warm-up period allows a compiler to make better optimization decisions, because it can observe (after initial class loading) a more complete class hierarchy. The compiler can also inspect branch and type profile information gathered by the interpreter.

JNI

The Java Native Interface - a specification and API for how Java code can call out to native C code, and how native C code can call into the Java VM

JVM TI

The Java Virtual Machine Tools Interface - a standard specification and API that is used by development and monitoring tools. See JVM TI for more information.

klass pointer

The second word of every object header. Points to another object (a metaobject) which describes the layout and behavior of the original object. For Java objects, the "klass" contains a C++ style "vtable".

mark word

The first word of every object header. Usually a set of bitfields including synchronization state and identity hash code. May also be a pointer (with characteristic low bit encoding) to synchronization related information. During GC, may contain GC state bits.

nmethod

A block of executable code which implements some Java bytecodes. It may be a complete Java method, or an 'OSR' method. It routinely includes object code for additional methods inlined by the compiler.

object header

Common structure at the beginning of every GC-managed heap object. (Every oop points to an object header.) Includes fundamental information about the heap object's layout, type, GC state, synchronization state, and identity hash code. Consists of two words. In arrays it is immediately followed by a length field. Note that both Java objects and VM-internal objects have a common object header format.

object promotion

The act of copying an object from one generation to another.

old generation

A region of the Java object heap that holds object that have remained referenced for a while.

on-stack replacement

Also known as 'OSR'. The process of converting an interpreted (or less optimized) stack frame into a compiled (or more optimized) stack frame. This happens when the interpreter discovers that a method is looping, requests the compiler to generate a special nmethod with an entry point somewhere in the loop (specifically, at a backward branch), and transfers control to that nmethod. A rough inverse to deoptimization.

oop

An object pointer. Specifically, a pointer into the GC-managed heap. (The term is traditional. One 'o' may stand for 'ordinary'.) Implemented as a native machine address, not a handle. Oops may be directly manipulated by compiled or interpreted Java code, because the GC knows about the liveness and location of oops within such code. (See GC map.) Oops can also be directly manipulated by short spans of C/C++ code, but must be kept by such code within handles across every safepoint.

parallel classloading

The ability to have multiple classes/type be in the process of being loaded by the same classloader at the same time.

parallel garbage collection

A garbage collection algorithm that uses multiple threads of control to perform more efficiently on multi-processor boxes.

permanent generation

A region of the address space that holds object allocated by the virtual machine itself, but which is managed by the garbage collector. The permanent generation is mis-named, in that almost all of the objects in it canbe collected, though they tend to be referenced for a long time, so they rarely become garbage.

remembered set

A data structure that records pointers between generations.

safepoint

A point during program execution at which all GC roots are known and all heap object contents are consistent. From a global point of view, all threads must block at a safepoint before the GC can run. (As a special case, threads running JNI code can continue to run, because they use only handles. During a safepoint they must block instead of loading the contents of the handle.) From a local point of view, a safepoint is a distinguished point in a block of code where the executing thread may block for the GC. Most call sites qualify as safepoints. There are strong invariants which hold true at every safepoint, which may be disregarded at non-safepoints. Both compiled Java code and C/C++ code be optimized between safepoints, but less so across safepoints. The JIT compiler emits a GC map at each safepoint. C/C++ code in the VM uses stylized macro-based conventions (e.g., TRAPS) to mark potential safepoints.

sea-of-nodes

The high-level intermediate representation in C2. It is an SSA form where both data and control flow are represented with explicit edges between nodes. It differs from forms used in more traditional compilers in that nodes are not bound to a block in a control flow graph. The IR allows nodes to float within the sea (subject to edge constraints) until they are scheduled late in the compilation process.

Serviceability Agent (SA)

The Serviceablity Agent is collection of Sun internal code that aids in debugging HotSpot problems. It is also used by several JDK tools - jstack, jmap, jinfo, and jdb. See SA for more information.

stackmap

Refers to the StackMapTable attribut e or a particular StackMapFrame in the table.

StackMapTable

An attribute of the Code attribute in a classfile which contains type information used by the new verifier during verification. It consists of an array of StackMapFrames. It is generated automatically by javac as of JDK6.

survivor space

A region of the Java object heap used to hold objects. There are usually a pair of survivor spaces, and collection of one is achieved by copying the referenced objects in one survivor space to the other survivor space.

synchronization

In general terms this is the coordination of concurrent activities to ensure the safety and liveness properties of those activities. For example, protecting access to shared data by using a lock to guard all code paths to that data.

TLAB

Thread-local allocation buffer. Used to allocate heap space quickly without synchronization. Compiled code has a "fast path" of a few instructions which tries to bump a high-water mark in the current thread's TLAB, successfully allocating an object if the bumped mark falls before a TLAB-specific limit address.

uncommon trap

When code generated by C2 reverts back to the interpreter for further execution. C2 typically compiles for the common case, allowing it to focus on optimization of frequently executed paths. For example, C2 inserts an uncommon trap in generated code when a class that is uninitialized at compile time requires run time initialization.

verifier

The software code in the VM which performs bytecode verification.

VM Operations

Operations in the VM that can be requested by Java threads, but which must be executed, in serial fashion by a specific thread known as the VM thread. These operations are often synchronous, in that the requester will block until the VM thread has completed the operation. Many of these operations also require that the VM be brought to a safepoint before the operation can be performed - a garbage collection request is a simple example.

write barrier

Code that is executed on every oop store. For example, to maintain a remembered set.

young generation

A region of the Java object heap that holds recently-allocated objects.

自旋锁（Spin lock）

自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。

自旋锁适用于锁保护的临界区很小的情况，临界区很小的话，锁占用的时间就很短。

简单的实现

SimpleSpinLock里有一个owner属性持有锁当前拥有者的线程的引用，如果该引用为null，则表示锁未被占用，不为null则被占用。

这里用AtomicReference是为了使用它的原子性的compareAndSet方法（CAS操作），解决了多线程并发操作导致数据不一致的问题，确保其他线程可以看到锁的真实状态

缺点

1. CAS操作需要硬件的配合；
2. 保证各个CPU的缓存（L1、L2、L3、跨CPU Socket、主存）的数据一致性，通讯开销很大，在多处理器系统上更严重；
3. 没法保证公平性，不保证等待进程/线程按照FIFO顺序获得锁。

Ticket Lock

Ticket Lock 是为了解决上面的公平性问题，类似于现实中银行柜台的排队叫号：锁拥有一个服务号，表示正在服务的线程，还有一个排队号；每个线程尝试获取锁之前先拿一个排队号，然后不断轮询锁的当前服务号是否是自己的排队号，如果是，则表示自己拥有了锁，不是则继续轮询。

当线程释放锁时，将服务号加1，这样下一个线程看到这个变化，就退出自旋。

简单的实现

缺点

Ticket Lock 虽然解决了公平性的问题，但是多处理器系统上，每个进程/线程占用的处理器都在读写同一个变量serviceNum ，每次读写操作都必须在多个处理器缓存之间进行缓存同步，这会导致繁重的系统总线和内存的流量，大大降低系统整体的性能。

下面介绍的CLH锁和MCS锁都是为了解决这个问题的。

MCS 来自于其发明人名字的首字母： John Mellor-Crummey和Michael Scott。

CLH的发明人是：Craig，Landin and Hagersten。

MCS锁

MCS Spinlock 是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，直接前驱负责通知其结束自旋，从而极大地减少了不必要的处理器缓存同步的次数，降低了总线和内存的开销。

CLH锁

CLH锁也是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，它不断轮询前驱的状态，如果发现前驱释放了锁就结束自旋。

CLH锁 与 MCS锁 的比较

下图是CLH锁和MCS锁队列图示：

差异：

1. 从代码实现来看，CLH比MCS要简单得多。
2. 从自旋的条件来看，CLH是在本地变量上自旋，MCS是自旋在其他对象的属性。
3. 从链表队列来看，CLH的队列是隐式的，CLHNode并不实际持有下一个节点；MCS的队列是物理存在的。
4. CLH锁释放时只需要改变自己的属性，MCS锁释放则需要改变后继节点的属性。

注意：这里实现的锁都是独占的，且不能重入的。

这个世界上有一类人特别苦逼，苦逼到什么程度呢？他们省吃俭用攒钱买房，结果房价越来越贵；公司外部竞争激烈，他们工作异常繁忙，披星戴月，日复一日；技术更新行业罕见，他们要随时调整心情，随时学习知识；他们长期和机器为伍，大多比较呆傻，比较单纯；还有很多不一一例举，这一类人就是程序员。

而就是这么一类程序员过着这么苦逼的生活，在公司内部却难以获得公平的晋升机会，外来的和尚总是在不断打破平衡，甚至是刚毕业的新和尚拿得都比老和尚多，这是全行业都罕见的奇观，IT人有幸经历了。

某创业公司，某个程序员要离职，老板甚至不问问他直接领导的意见，就同意了，没有挽留，之后大骂不忠诚，这个人拿3k，拿了2年，他走了以后，老板用5k雇了个新面孔，但就是不愿意给这个老人晋升，不愿意给加到哪怕是4k。

某上市公司，游戏部门突然从外部空降了一个领导，原因是原大佬被挖走以后，剩下的人升谁都有意见，难以服众，不从外部请人来镇不住局面，这个人一来，大家是团结了，团结起来和这个人斗，但最后还是和解了。

某国际大公司，某人伪造简历，包装的如花似玉，获得高职，工作主要有下属完成，他只需要汇众汇报即可，越混路越宽，直到某天事发，依然是高官。

某IT企业，某清华同学离职时语重心长的对我说，XX（可以理解为网游，搜索，电商任意一种）是00-02年毕业的这些人清华人的机会，我们就是比某人强十倍也没有机会，也得从下面做起，搜索的天时不属于我，此人去了某金融分析软件公司，目前是高管，同期留在某IT企业的其他同学依然过着苦逼的生活。

举了这么多例子，我想说得是为什么不给你晋升这个问题，或者晋升很难，为什么？

1）大佬的问题

你晋升困难，最大的主观原因在你自己，最大的客观原因在你的直接上司。付责任人的说，目前很多企业的领导是不合格的，他们大多80后，没有为他人着想的思想基础，一味的考虑自己，不顾下属，曾经我对某人说，你说你是合格的领导，你说出你下属每个员工租房在哪里，每月多少房租，我就同意你是合格的领导，结果他羞愧不言。你晋升不了，很大程度上是你的领导没有帮你，连你每月房租多少都不知道，你指望他帮助你提高技术水平，帮助你晋升？

2）大佬的大佬的问题

你大佬的大佬，level很高，他需要引入新鲜血液，他知道这个队伍缺什么，这个是他思考的问题，他需要找牛的人来补这个缺口，于是一个光鲜照人的牛人进来了（虽然两年后也会泯为众人）给队伍带来了新鲜的血液，但你的大佬升不上去，你大佬边上的位置被这个人占了，你的位置在哪？

3）公司的问题

各大企业给员工的再教育和培训都是不尽相同的，但大多口号是一致的，在工作中锻炼成长，这句话是最扯淡的，国外很多大公司是有很完善的培训和再教育计划的，会给员工一个充电的机会，并且给其一个完善的培训后，以便于让他在新升职的岗位上能够很好的胜任。在国内大公司都在找牛人，就是不愿意自己培养，原因是什么，不解释，你懂得。

4）你的兄弟

很多时候让你升不了职恰恰是因为和你一起战斗的兄弟，他们工作也很不错，你升职了，他们怎么办？这也是一个平衡的问题，你很努力，为什么你没有带动你的兄弟一起努力，你上去了，需要你这帮兄弟的支持，他们会支持你吗？曾有一个说了一句话，我觉得很值得回味，“当大家都认为你该升职了，就是你升职的时候了”，细细品味，很有道理。

5）你自己的问题

最后你升不了职是你自己的问题，每天工作很忙，没时间充电，每天工作压力很大，来不及学习，每天这个那个，一年下来碌碌无为。你提高了自己的效率了嘛？你周围有朋友再帮你吗？你知道你要学什么嘛？你知道什么样的工作才能超出领导的期望?，你超出领导期望后却没有升职和领导沟通过吗？我曾在某企业，我周围的几乎所有人加薪升职都是和领导沟通后才获得的。指望主动给你加薪升职，不如指望自己的沟通。

6）还是你自己的问题

你选择的这个行业是不是对的，公司是不是对的，就好像我说的这个清华的同学这个例子。如果你能耐大可以选大公司，PK到一票牛人上去，如果你能耐不大，去成熟大公司，还心理期盼高薪升职就不现实了，不如去一个有前途的中小公司，开创自己的事业。

从企业角度出发，如何创建一个合理公平的晋升机制呢？

1）第一流大佬才会招第一流的人，第二流大佬只会招第三流的人，因此公司一把手必须是第一流的，价值观才能靠谱，制度才靠谱，没熟读历史，不理解中国文化的，建议不要做公司一把手。

2）晋升的制度必须公平，面向每一个人，每一个层次，这往往很难做到，做前端的和做后台的不好比，但做前端的可以和做前端的比。必须要有公开公平的比拼，已获得升职机会。例如某公司做一个高维矩阵分解的难题，大家机会均等，性能最快，效果最好，胜出者升职，带领团队。

3）鼓励公司职员交流，传播和帮助他人的文化，一个人如果乐于助人，帮助他人提高技术水平，这个人升职升上来，大家都会顶，反之，你保守，不帮助他人，水平再牛，升职上来也没人支持。

4）可以给职员一些挑战的机会，提供更多的资源，比如某公司的闪电计划，超越了谷歌搜索效果，就是一个很好的例子，要敢于给一些勇于挑战的职员更多的资源，在严酷的战斗中考验，并提供充分弹药。

5）给予内训机会，邀请业界牛人讲座，送职员去美帝考察开会乃至工作等等。培训机会是发达国家企业的一种非常好的激励措施，一个岗位5个人培训，最好的上岗，这是一个很公平的机会，培训机构足够独立。   
方法有很多，只要这第一流的大佬，心中有着这帮打生打死的兄弟，办法总是有的，不要总是考虑自己的业绩，考虑自己的乌纱帽，做到这一点很难很难，但制度不是只有这位大佬可以制定，任何职员都应该积极投身到制度建立的过程中，要敢于提出自己的观点，毕竟公司是大家的公司。

我就写这么多，我是一个十年一线程序员的身份写这篇博客的，我努力做到客观，但我相信我更多代表的是劳方立场。

http://docs.huihoo.com/java/jmx/jmx_base.html

http://blog.csdn.net/honno/article/details/1798476

　　《福布斯》杂志评出了上个世纪末最具影响力的二十本商业书籍。上世纪70年代末，美国经济陷入衰退的阵痛期，来自阿拉伯世界的石油威胁及来自日本的经济压力使美国人的日子很不好过，商业书籍也因此被尘封一时。但在接下来的80和90年代，美国经济保持了二十年的持续增长，一大批优秀的CEO如比尔·盖茨、李·艾科卡、唐纳德·特朗普，出现在人们的视野中。商业书籍的出版和发行也因此空前活跃，本次评出的二十本书按类别分为管理类、叙事类、投资类及传记类。它们分别是：

　　汤姆·彼得斯错了吗？

　　管理类书籍在整个排行榜上所占的比重最大，其中汤姆·彼得斯(Thomas Peters)的《追求卓越》高居榜首。这本书出版于1982年，最开始源自著名的咨询公司麦肯锡的一个内部项目。当时的美国商业界正倍受日本公司咄咄逼人的扩张姿态的困扰，日本公司普遍采用的严格的制度化管理让这个战败国的经济迅速崛起。面对强烈个人主义精神的员工，美国公司领导成了被长期讥笑的低能者。汤姆·彼得斯与罗伯特·沃特曼的《追求卓越》成了美国商业的拯救者。这本书为管理设定了一个积极的目标，而非强调面临的难题。彼得斯提出的杰出企业的 8个特性几乎为未来20年的商业管理奠定了格局：

　　1.偏好行动而不是沉思

　　2.在产品和服务上接近顾客的需求

　　3.鼓励自治和放松，而不是紧密监督

　　4.对雇员的态度是鼓励其生产力，避免“我们”和“他们”这种对立情绪

　　5.以一种被称为“走动式管理”保持与大家的紧密接触

　　6.“专注于自身”以保持商业优势，因此避免了无关的风险

　　7.组织结构简洁，人员精干

　　8.对目标同时保持松紧有度的特性，但却不窒息创新的控制系统。

　　今日的企业领袖没有人不承认深受汤姆·彼得斯原则的影响。《追求卓越》成为第一本销量超过百万的商业书籍，这本书甚至促成了商业书籍出版业的成熟。汤姆·彼得斯也成了一位标志性的明星人物。

　　今日的汤姆·彼得斯已经失去了最初的光彩，人们甚至开始遗忘他了。在《追求卓越》出版20周年之际，汤姆·彼得斯亲自撰文，讲述他写这本书的初衷和过程，他的观点对在哪里，错在哪里，他承认当时自己说了一些谎话。对于试图为商界确定未来日程的精英来说，《追求卓越》背后的故事提供了一系列不可多得的教训。此书引导的潮流向我们展示了20年来商业世界急剧变化的生动图景。

　　“我们忘了贴一个警告标签。注意！没有永恒的东西。任何东西吃得太多都会有毒。请记住：商业中所有事情都是悖论。为达到追求，必须持之以恒。而当你持之以恒之时，你就容易受到攻击。你看，这就是悖论。面对它吧！”这是此书出版20年之后汤姆·彼得斯的再一次表白，“卓越只是一种过于静态的观念，而世界实在变化太快了。”

　　好公司能否变成卓越公司

　　排名第二的是吉姆·柯林斯(James C. Collins)和杰里·波拉斯(Jerry I. Porras)的著作《基业长青》。在书中作者对那些有见识有远见的公司进行了介绍。许多人认为一间公司的持续成长依赖于几位优秀的CEO的持续运作，但本书的作者却告诉人们，对一个企业而言，一群聪明人在维持现状的基础上敢于进行新尝试比拥有一个有魅力的领袖更重要，而拥有一个核心的理念并为之奋斗则是企业的关键所在。

　　吉姆·柯林斯的另一本书《从优秀到卓越》同样榜上有名。

　　《基业长青》这本书研究了18个基业常青公司的成功经验。这些公司包括沃尔玛、惠普、宝洁、3M和索尼等行业领袖，本书研究的是事件，是人性。作者从人的角度让我们看到了公司的成长和巩固。作者分析的是公司、组织以及人在组织中的作用。作者从公司的角度分析了使得企业长远发展的优势，以此分析企业取得这些优势并长期发展的原因。企业在发展过程中必须不断自我改革、自我反省来达到这些优势，使其成为公司特性，从而保证长久发展。

　　为了进一步探寻那些优秀的公司走向不同发展道路的因素，2001年，吉姆·柯林斯又出版了一本《从优秀到卓越》，这本书可说是《基业长青》的姊妹篇。还在出版《基业长青》之时，柯林斯就提出，好的公司能否变成卓越的公司？如果能够，他们如何才能实现呢？之后，他们对1400多个公司进行了研究，最后得出了结论，这是可以达到的。那些由优秀的公司变为伟大公司的佼佼者并不一定都拥有最新的技术、最擅长管理的CEO，他们最有力的武器是他们的公司文化，一种激励每个人都按照他们想要的方式去工作的文化。综合这两本书，我们已经知道如何由一个优秀的公司发展成为一个卓越的公司，这些公司都是经历了时间考验的。那些正在变革的路口，不知要去向何方的公司或许能在科林斯的书中找到一些提示和方向。

　　《公司再造》潮流的起落

　　《追求卓越》和《基业长青》集中介绍企业如何取得超人的成就，而排名第三的《公司再造》(Reengineering the Corporation：A Manifesto for Business Revolution)则聚焦在企业如何进行自我改造。书中研究了福特、IBM及贝尔公司的案例并介绍了相关的成功经验。

　　1993年，迈克尔·汉默(Michael Hammer)与James Champy出版了《企业再造》一书，系统阐述了BPR(Business Process Reengineering)的思想，提出再造企业的首要任务是BPR，只有建设好BPR，才能使企业彻底摆脱困境。至此，BPR作为一种新的管理思想，像一股风潮席卷了整个美国和其他工业化国家。

　　BPR就是将企业的业务过程描绘成一个价值链(Value Chain)，竞争不是发生在企业与企业之间，而是发生在企业各自的价值链之间。只有对价值链的各个环节(业务流程)实行有效管理的企业，才有可能真正获得市场上的竞争优势，也惟其如此，BPR才被捧为“恢复美国竞争力的惟一途径”。

　　BPR的产生，并不仅仅是一本书那么简单，隐藏在BPR背后的是深刻的技术、经济以及管理变革背景。

　　资本主义进入70年代以来，全球经济环境发生了巨大的变化，供大于求的现状促成了卖方市场转向买方市场。进入80年代，以美国为代表的资本主义发达国家经济陷入增长缓慢和通货膨胀的尴尬困境，企业陷入了成本增加、效益降低的局面，产品竞争力与亚太国家相比陷入不断下降的局面。美国的企业迫切期望改变这种现状，走出低谷，从70到90年代陆续出现的新型管理手段以及管理方法为BPR奠定了腾空而出的基础条件。

　　90年代初应运而生的BPR正好迎合了企业的这种思想和需要。BPR完全满足了欧美企业急于走出经济萧条、寻求持续增长和适应新的商业规则的心理需求，也满足了学术界在迷茫中寻求管理思想革新的迫切心理。

　　BPR从1990年概念的诞生，短短3年的时间，到1993年达到顶峰，在美国几乎形成一股风潮，同时还波及到日本、德国等其他工业化国家。1990年到1995年是BPR在欧美最为鼎盛的时期。90年代末期，经济的持续稳定导致BPR成为美国企业率先遗弃的对象。

　　另一本受欢迎的书籍《高效人群的七种习惯》着重介绍个人管理。这本书虽然已经出版了十多年之久，并已达到了上千万的销量，但时至今日仍然是图书市场上的宠儿。有趣的是，虽然数以千万计的人购买了它，但人们的平均工作效率似乎并没有比十年前有所提高。本书作者史蒂芬·柯维却因此名声大振，他的私人公司富兰克林·柯维(Franklin Covey)在2001年的销售额高达5亿2000万美元。

　　还有一位值得一提的作者当数彼得·德鲁克。他所写的管理学著作早在汤姆·彼得斯的《追求卓越》之前。在本次评选中，他的《德鲁克的核心思想》被公认为是最有影响力的商业书籍之一。

　　杰克·韦尔奇：再老也会让你惊讶

　　CEO的传记历来都是出版商追捧的对象，然而最早的CEO传记——1985年由Bantam出版公司推出的《艾科卡》(《Lacocca》) 在此次评选中却榜上无名。同样名噪一时的传记体书籍《交易的艺术》(1988年，Random House公司出版)也与排行榜无缘。

　　由华纳公司出版的《杰克·韦尔奇自传》受到评选人士的一致认可。近来，CEO杰克·韦尔奇虽然在婚姻问题上颇受争议，但他仍然被公认为代表了一个时代的最杰出的CEO人选。同他合著该书的《商业周刊》的约翰·伯恩的著作《价值链》也在评选中颇受关注。

　　杰克·韦尔奇在担任通用公司CEO的20年中，带领这个工业巨人积累了超过4500亿美元的市场资本，并使自己成为全世界最受人尊敬的企业领导。他提倡并促进了现代企业的电子商务、六西格玛体系——即在100万次生产或服务作业中的瑕疵率不超过6次、质量体系和全球化进程。同时，他建立了一套独特的企业哲学和管理方法。其理念是打破一切界限地吸收有用的思想；把人当成企业的核心；建立自由的投入产出模式，以抵御官僚主义的产生。

　　杰克带领通用公司进入了“中子杰克”时代，他在每一个通用企业中推行“整顿、出售和关闭”的策略，从而使通用公司逐步裁减了10万雇员；他通过购并RCA公司为通用未来的赢利奠定了基础……当然，也有失误的时候，但是杰克能够用一种坦诚的心态去面对失误。在“自大的自己”这一章中，他承认收购Kidder Peabody公司是自己最大的失败，因为该公司和通用公司的文化背道而驰。对于在职业生涯最后一年煞费苦心地收购霍尼韦尔并遭遇失败的全过程，本书也做了详尽的交代。这位善于自嘲的经理人说这让他明白了一个道理：再老也会有让你惊讶的事情。的确，如果韦尔奇撰写自传续集的话，他会向读者解释他的婚姻危机和关于巨额退休金的满城风雨吗？

　　在传记类作品中，另一本著名的传记《摩根财团》于1990年问世，书中描述了J.P.摩根的帝国如何从诞生到陨落的过程，该书获得了1990 年全美最佳图书奖，并在商界人士之中广泛流传。微软的总裁比尔·盖茨是这个时代最富有的人，他的两本描述信息世界的书《未来之路》和《未来时速》虽然引人注目，但却没有荣登本次排行榜。

排名榜单

Python没有内建一个编译为exe的功能。给python程序的部署带来不少的麻烦。

所以就会出现一些py2exe之类的很不错的工具，用于自动把.py文件编译为.exe文件。

最近抽空研究了一下手动实现类似py2exe的功能，希望加强对python的了解。

结果还相当不错。把结果记录下来，与大家共享。

原理

文中所描述的方法，基于python的以下几个功能

1. python程序运行时，会在sys.path指定的路径中查找库文件。

2. python从2.3开始，支持从zip文件中import库(支持.py,.pyc和.pyo，但不支持.pyd)

3. python提供C API，让c语言的程序，可以很方便的调用python的程序

实际步骤

注：假设python安装在c:\python25目录中，最后的可执行文件放到d:\dist目录中

1. 先去c:\python25\Lib目录，把所有文件都复制出来，比如复制到d:\pythonlib目录中

2. 开一个cmd窗口，进入d:\pythonlib目录中，运行 python -OO compileall.py -f . 把lib中的.py文件都编译成.pyo文件

3. 删除d:\pythonlib目录中所有的.py和.pyc文件，因为我们只要有.pyo文件就可以让这些库运行了。

4. 删除目录中所有用不着的文件，比如curses，test，idlelib，msilib等，以减少生成文件的体积。

5. 把这些库打包成一个zip文件，比如stdlib.zip，放到d:\dist目录中

6. 把c:\python25\dlls目录中的.pyd和.dll文件，复制到d:\dist\dlls目录中，当然，删除不可能用到的一些文件_msi.pyd,_ssl.pyd等等，可以减少文件的体积

7. 把自己写的程序，也按步骤2至步骤5所说的方法，打成一个mysrc.zip包，放到d:\dist目录中。 注意：自己写的程序的入口应该是main.pyo文件

8. 用以下C程序编译出一个可执行文件，比方说叫runpy.exe，也放到d:\dist中。

 1#include <Python.h>
 2#include <Windows.h>
 3#include <stdlib.h>
 4#include <stdio.h>
 5
 6int main()
 7{
 8        // 得到当前可执行文件所在的目录
 9        char szPath[10240];
10        char szCmd[10240];
11        GetModuleFileName(NULL, szPath, sizeof(szPath));
12        char* p = strrchr(szPath, '\\');
13        if (p == NULL)
14        {
15                printf("Get module file name error!\n");
16                return -1;
17        }
18
19        *p = 0;
20
21        // 设定运行时的PATH
22        sprintf(szCmd, "PATH=%s\\dlls;%%PATH%%", szPath);
23        _putenv(szCmd);
24
25        // 把sys.path设定为['.', '自己的源代码zip文件', '标准库zip文件', 'dll目录']
26        // 然后调用main模块
27        sprintf(szCmd,
28                "import sys\n"
29                "sys.path=['.', r'%s\\mysrc.zip', r'%s\\stdlib.zip', r'%s\\dlls']\n"
30                "import main\n",
31                szPath, szPath, szPath);
32        
33        Py_OptimizeFlag = 2;
34        Py_NoSiteFlag = 1;
35        Py_Initialize();
36        PyRun_SimpleString(szCmd);
37        return 0;
38}
39

9. 把python25.dll放到d:\dist目录中。

结束语

这样来，d:\dist目录中，一共只有4个文件加一个目录：

• dlls目录：用于存放所有的dll文件和pyd文件

• stdlib.zip文件：用于存放所有的python的.pyo文件格式的标准库

• mysrc.zip文件：用于存放自己写的程序。注意，自己写的程序的入口在main.pyo中。

• runpy.exe文件：程序的启动文件，启动后会设定python的sys.path，然后调用main模块

• python25.dll文件：python的核心dll，runpy.exe依赖于这个dll

• 哈哈，相当的简洁明了吧。一共才4个文件一个目录，5MB都不到哦。

注：当然，这种打包方式第一次做的时候比较麻烦，但之后就可以只要把自己的程序打包就好了，其它的不用变。

而且，如果自己的程序经常做改动的话，自己的程序也可以不打包，直接放到d:\dist中，反正runpy.exe启动程序的时候，只要能正常运行import main就可以了。

有不少人写email给我，问我要我做的包。大家可以在这里下载基于2.5.2版本的包： python_dist.7z 以及基于3.1.2版本的包： python31-dist.7z

注：3.1.2依赖于visual c++ 2008 redistributable package. 如果在目标机器上没有安装，则程序运行不起来。

解开包后，只要用自己的程序替换mysrc.zip就可以使用了。

包里有runpy.exe和runpyw.exe两个文件。其中，runpy.exe是控制台程序，runpyw.exe是非控制台程序。这两个程序分别类似于python.exe和pythonw.exe。想让程序运行时出现一个控制台，就运行runpy.exe，如果不想出现黑黑的控制台，就运行runpyw.exe。