public interface KryoPool {

	....

	/** Runs the provided {@link KryoCallback} with a {@link Kryo} instance from the pool (borrow/release around
	 * {@link KryoCallback#execute(Kryo)}). */
	<T> T run (KryoCallback<T> callback);

	// 1
	/** Builder for a {@link KryoPool} instance, constructs a {@link KryoPoolQueueImpl} instance. */
	public static class Builder {

		private final KryoFactory factory;
		private Queue<Kryo> queue = new ConcurrentLinkedQueue<Kryo>();
		private boolean softReferences;

		public Builder (KryoFactory factory) {
			if (factory == null) {
				throw new IllegalArgumentException("factory must not be null");
			}
			this.factory = factory;
		}

		/** Use the given queue for pooling kryo instances (by default a {@link ConcurrentLinkedQueue} is used). */
		public Builder queue (Queue<Kryo> queue) {
			if (queue == null) {
				throw new IllegalArgumentException("queue must not be null");
			}
			this.queue = queue;
			return this;
		}

		/** Use {@link SoftReference}s for pooled {@link Kryo} instances, so that instances may be garbage collected when there's
		 * memory demand (by default disabled). */
		public Builder softReferences () {
			softReferences = true;
			return this;
		}

		/** Build the pool. */
		// 2
		public KryoPool build () {
			Queue<Kryo> q = softReferences ? new SoftReferenceQueue(queue) : queue;
			return new KryoPoolQueueImpl(factory, q);
		}

		....
	}

}

/** Callback to run with a provided kryo instance.
 *
 * @author Martin Grotzke
 *
 * @param <T> The type of the result of the interaction with kryo. */
public interface KryoCallback<T> {
	T execute (Kryo kryo);
}

/** Internally uses {@link SoftReference}s for queued Kryo instances, most importantly adjusts the {@link Queue#poll() poll}
 * behavior so that gc'ed Kryo instances are skipped. Most other methods are unsupported.
 *
 * @author Martin Grotzke */
class SoftReferenceQueue implements Queue<Kryo> {

	private Queue<SoftReference<Kryo>> delegate;

	public SoftReferenceQueue (Queue<?> delegate) {
		this.delegate = (Queue<SoftReference<Kryo>>)delegate;
	}

	....
}

/** @param referenceResolver May be null to disable references. */
	public Kryo (ClassResolver classResolver, ReferenceResolver referenceResolver, StreamFactory streamFactory) {
		if (classResolver == null) throw new IllegalArgumentException("classResolver cannot be null.");

		this.classResolver = classResolver;
		classResolver.setKryo(this);

		this.streamFactory = streamFactory;
		streamFactory.setKryo(this);

		this.referenceResolver = referenceResolver;
		if (referenceResolver != null) {
			referenceResolver.setKryo(this);
			references = true;
		}

		addDefaultSerializer(byte[].class, ByteArraySerializer.class);
		addDefaultSerializer(char[].class, CharArraySerializer.class);
		addDefaultSerializer(short[].class, ShortArraySerializer.class);
		addDefaultSerializer(int[].class, IntArraySerializer.class);
		addDefaultSerializer(long[].class, LongArraySerializer.class);
		addDefaultSerializer(float[].class, FloatArraySerializer.class);
		addDefaultSerializer(double[].class, DoubleArraySerializer.class);
		addDefaultSerializer(boolean[].class, BooleanArraySerializer.class);
		addDefaultSerializer(String[].class, StringArraySerializer.class);
		addDefaultSerializer(Object[].class, ObjectArraySerializer.class);
		addDefaultSerializer(KryoSerializable.class, KryoSerializableSerializer.class);
		addDefaultSerializer(BigInteger.class, BigIntegerSerializer.class);
		addDefaultSerializer(BigDecimal.class, BigDecimalSerializer.class);
		addDefaultSerializer(Class.class, ClassSerializer.class);
		addDefaultSerializer(Date.class, DateSerializer.class);
		addDefaultSerializer(Enum.class, EnumSerializer.class);
		addDefaultSerializer(EnumSet.class, EnumSetSerializer.class);
		addDefaultSerializer(Currency.class, CurrencySerializer.class);
		addDefaultSerializer(StringBuffer.class, StringBufferSerializer.class);
		addDefaultSerializer(StringBuilder.class, StringBuilderSerializer.class);
		addDefaultSerializer(Collections.EMPTY_LIST.getClass(), CollectionsEmptyListSerializer.class);
		addDefaultSerializer(Collections.EMPTY_MAP.getClass(), CollectionsEmptyMapSerializer.class);
		addDefaultSerializer(Collections.EMPTY_SET.getClass(), CollectionsEmptySetSerializer.class);
		addDefaultSerializer(Collections.singletonList(null).getClass(), CollectionsSingletonListSerializer.class);
		addDefaultSerializer(Collections.singletonMap(null, null).getClass(), CollectionsSingletonMapSerializer.class);
		addDefaultSerializer(Collections.singleton(null).getClass(), CollectionsSingletonSetSerializer.class);
		addDefaultSerializer(TreeSet.class, TreeSetSerializer.class);
		addDefaultSerializer(Collection.class, CollectionSerializer.class);
		addDefaultSerializer(TreeMap.class, TreeMapSerializer.class);
		addDefaultSerializer(Map.class, MapSerializer.class);
		addDefaultSerializer(TimeZone.class, TimeZoneSerializer.class);
		addDefaultSerializer(Calendar.class, CalendarSerializer.class);
		addDefaultSerializer(Locale.class, LocaleSerializer.class);
		addDefaultSerializer(Charset.class, CharsetSerializer.class);
		addDefaultSerializer(URL.class, URLSerializer.class);
		OptionalSerializers.addDefaultSerializers(this);
		TimeSerializers.addDefaultSerializers(this);
		lowPriorityDefaultSerializerCount = defaultSerializers.size();

		// Primitives and string. Primitive wrappers automatically use the same registration as primitives.
		register(int.class, new IntSerializer());
		register(String.class, new StringSerializer());
		register(float.class, new FloatSerializer());
		register(boolean.class, new BooleanSerializer());
		register(byte.class, new ByteSerializer());
		register(char.class, new CharSerializer());
		register(short.class, new ShortSerializer());
		register(long.class, new LongSerializer());
		register(double.class, new DoubleSerializer());
		register(void.class, new VoidSerializer());
	}

/** Writes the class and object or null using the registered serializer.
	 * @param object May be null. */
	public void writeClassAndObject (Output output, Object object) {
		if (output == null) throw new IllegalArgumentException("output cannot be null.");
		beginObject();
		try {
			if (object == null) {
				writeClass(output, null);
				return;
			}
            //返回注册对象
			Registration registration = writeClass(output, object.getClass());
            //使用references方式序列化,writeReferenceOrNull 从缓存中获取,则执行下列代码,也就是不执行write操作.因为数据已经序列化到缓存了.
            //非第1次或者null,数据已经存在缓存中,不需要执行其他逻辑
            //true：缓存中存在数据
            //false：缓存中不存在数据
			if (references && writeReferenceOrNull(output, object, false)) {
                //设置泛型
				registration.getSerializer().setGenerics(this, null);
				return;
			}
			if (TRACE || (DEBUG && depth == 1)) log("Write", object);
            //注册对象获取serializer的write方式进行序列化,相当于实时执行序列化
            //基本数据类型的引用是实时write
			registration.getSerializer().write(this, output, object);
		} finally {
			if (--depth == 0 && autoReset) reset();
		}
	}

public Kryo () {
		this(new DefaultClassResolver(), new MapReferenceResolver(), new DefaultStreamFactory());
}

/** @param object May be null if mayBeNull is true.
	 * @return true if no bytes need to be written for the object. */
	//第1次、基本类型return false；非第1次、null return true
    //true：缓存中存在数据
    //false：缓存中不存在数据
	boolean writeReferenceOrNull (Output output, Object object, boolean mayBeNull) {
		if (object == null) {
			if (TRACE || (DEBUG && depth == 1)) log("Write", null);
			//null object 在byte缓存的数据范围
			output.writeVarInt(Kryo.NULL, true);
			return true;
		}
		//true:基本类型对象；false：引用对象
		if (!referenceResolver.useReferences(object.getClass())) {
			//基本类型对象的not null存储范围
			if (mayBeNull) output.writeVarInt(Kryo.NOT_NULL, true);
			return false;
		}

		// Determine if this object has already been seen in this object graph.
		//从缓存中获取referenceId
		int id = referenceResolver.getWrittenId(object);

		// If not the first time encountered, only write reference ID.
		//非第1次
		if (id != -1) {
			if (DEBUG) debug("kryo", "Write object reference " + id + ": " + string(object));
			output.writeVarInt(id + 2, true); // + 2 because 0 and 1 are used for NULL and NOT_NULL.
			return true;
		}
		//第1次,添加到缓存中
		// Otherwise write NOT_NULL and then the object bytes.
		id = referenceResolver.addWrittenObject(object);
		output.writeVarInt(NOT_NULL, true);
		if (TRACE) trace("kryo", "Write initial object reference " + id + ": " + string(object));
		return false;
	}

/** Describes the {@link Serializer} and class ID to use for a class.
 * @author Nathan Sweet <misc@n4te.com> */
public class Registration {
	/**
	 * 注册类
	 */
	private final Class type;
	/**
	 * 注册的id
	 */
	private final int id;
	/**
	 * 序列化方式
	 */
	private Serializer serializer;
	/**
	 * 复制对象
	 */
	private ObjectInstantiator instantiator;

	...
}

/** Reads and writes objects to and from bytes.
 * @author Nathan Sweet <misc@n4te.com> */
public abstract class Serializer<T> {
    //允许为空、不可变
	private boolean acceptsNull, immutable;

	public Serializer () {
	}

	/** @see #setAcceptsNull(boolean) */
	public Serializer (boolean acceptsNull) {
		this.acceptsNull = acceptsNull;
	}

	/** @see #setAcceptsNull(boolean)
	 * @see #setImmutable(boolean) */
	public Serializer (boolean acceptsNull, boolean immutable) {
		this.acceptsNull = acceptsNull;
		this.immutable = immutable;
	}

	/** Writes the bytes for the object to the output.
	 * <p>
	 * This method should not be called directly, instead this serializer can be passed to {@link Kryo} write methods that accept a
	 * serialier.
	 * @param object May be null if {@link #getAcceptsNull()} is true. */
	abstract public void write (Kryo kryo, Output output, T object);

	/** Reads bytes and returns a new object of the specified concrete type.
	 * <p>
	 * Before Kryo can be used to read child objects, {@link Kryo#reference(Object)} must be called with the parent object to
	 * ensure it can be referenced by the child objects. Any serializer that uses {@link Kryo} to read a child object may need to
	 * be reentrant.
	 * <p>
	 * This method should not be called directly, instead this serializer can be passed to {@link Kryo} read methods that accept a
	 * serialier.
	 * @return May be null if {@link #getAcceptsNull()} is true. */
	abstract public T read (Kryo kryo, Input input, Class<T> type);

	public boolean getAcceptsNull () {
		return acceptsNull;
	}

	/** If true, this serializer will handle writing and reading null values. If false, the Kryo framework handles null values and
	 * the serializer will never receive null.
	 * <p>
	 * This can be set to true on a serializer that does not accept nulls if it is known that the serializer will never encounter
	 * null. Doing this will prevent the framework from writing a byte to denote null. */
	public void setAcceptsNull (boolean acceptsNull) {
		this.acceptsNull = acceptsNull;
	}

	public boolean isImmutable () {
		return immutable;
	}

	/** If true, the type this serializer will be used for is considered immutable. This causes {@link #copy(Kryo, Object)} to
	 * return the original object. */
	public void setImmutable (boolean immutable) {
		this.immutable = immutable;
	}

	/** Sets the generic types of the field or method this serializer will be used for on the next call to read or write.
	 * Subsequent calls to read and write must not use this generic type information. The default implementation does nothing.
	 * Subclasses may use the information provided to this method for more efficient serialization, eg to use the same type for all
	 * items in a list.
	 * @param generics Some (but never all) elements may be null if there is no generic type information at that index. */
	public void setGenerics (Kryo kryo, Class[] generics) {
	}

	/** Returns a copy of the specified object. The default implementation returns the original if {@link #isImmutable()} is true,
	 * else throws {@link KryoException}. Subclasses should override this method if needed to support {@link Kryo#copy(Object)}.
	 * <p>
	 * Before Kryo can be used to copy child objects, {@link Kryo#reference(Object)} must be called with the copy to ensure it can
	 * be referenced by the child objects. Any serializer that uses {@link Kryo} to copy a child object may need to be reentrant.
	 * <p>
	 * This method should not be called directly, instead this serializer can be passed to {@link Kryo} copy methods that accept a
	 * serialier. */
	public T copy (Kryo kryo, T original) {
		if (immutable) return original;
		throw new KryoException("Serializer does not support copy: " + getClass().getName());
	}
}

/** Uses an {@link IdentityObjectIntMap} to track objects that have already been written. This can handle graph with any number of
 1. objects, but is slightly slower than {@link ListReferenceResolver} for graphs with few objects.
 2. @author Nathan Sweet <misc@n4te.com> */
public class MapReferenceResolver implements ReferenceResolver {
	protected Kryo kryo;
	/**
	 * 存储id、reference的Map
	 */
	protected final IdentityObjectIntMap writtenObjects = new IdentityObjectIntMap();
	/**
	 * read根据id作为list的index，获取reference
	 */
	protected final ArrayList readObjects = new ArrayList();

	public void setKryo (Kryo kryo) {
		this.kryo = kryo;
	}

	public int addWrittenObject (Object object) {
		int id = writtenObjects.size;
		writtenObjects.put(object, id);
		return id;
	}

	public int getWrittenId (Object object) {
		return writtenObjects.get(object, -1);
	}

	public int nextReadId (Class type) {
		int id = readObjects.size();
		readObjects.add(null);
		return id;
	}

	public void setReadObject (int id, Object object) {
		readObjects.set(id, object);
	}

	public Object getReadObject (Class type, int id) {
		return readObjects.get(id);
	}

	public void reset () {
		readObjects.clear();
		writtenObjects.clear();
	}

	/** Returns false for all primitive wrappers. */
	//true：引用对象
	public boolean useReferences (Class type) {
		return !Util.isWrapperClass(type);
	}
}

public void put (K key, int value) {
		if (key == null) throw new IllegalArgumentException("key cannot be null.");
		// avoid getfield opcode
		K[] keyTable = this.keyTable;
		int mask = this.mask;
		boolean isBigTable = this.isBigTable;

		// Check for existing keys.
		// 从缓存中获取值,4个hashcode中获取值
		int hashCode = System.identityHashCode(key);
		int index1 = hashCode & mask;
		K key1 = keyTable[index1];
		if (key == key1) {
			valueTable[index1] = value;
			return;
		}

		int index2 = hash2(hashCode);
		K key2 = keyTable[index2];
		if (key == key2) {
			valueTable[index2] = value;
			return;
		}

		int index3 = hash3(hashCode);
		K key3 = keyTable[index3];
		if (key == key3) {
			valueTable[index3] = value;
			return;
		}

		int index4 = -1;
		K key4 = null;
		if (isBigTable) {
			index4 = hash4(hashCode);
			key4 = keyTable[index4];
			if (key == key4) {
				valueTable[index4] = value;
				return;
			}
		}

		// Update key in the stash.
		for (int i = capacity, n = i + stashSize; i < n; i++) {
			if (keyTable[i] == key) {
				valueTable[i] = value;
				return;
			}
		}

		// Check for empty buckets.
		if (key1 == null) {
			keyTable[index1] = key;
			valueTable[index1] = value;
			if (size++ >= threshold) resize(capacity << 1);
			return;
		}

		if (key2 == null) {
			keyTable[index2] = key;
			valueTable[index2] = value;
			if (size++ >= threshold) resize(capacity << 1);
			return;
		}

		if (key3 == null) {
			keyTable[index3] = key;
			valueTable[index3] = value;
			if (size++ >= threshold) resize(capacity << 1);
			return;
		}

		if (isBigTable && key4 == null) {
			keyTable[index4] = key;
			valueTable[index4] = value;
			if (size++ >= threshold) resize(capacity << 1);
			return;
		}

		push(key, value, index1, key1, index2, key2, index3, key3, index4, key4);
	}

/** @param defaultValue Returned if the key was not associated with a value. */
	public int get (K key, int defaultValue) {
		int hashCode = System.identityHashCode(key);
		int index = hashCode & mask;
		if (key != keyTable[index]) {
			index = hash2(hashCode);
			if (key != keyTable[index]) {
				index = hash3(hashCode);
				if (key != keyTable[index]) {
					if (isBigTable) {
						index = hash4(hashCode);
						if (key != keyTable[index]) return getStash(key, defaultValue);
					} else {
						return getStash(key, defaultValue);
					}
				}
			}
		}
		return valueTable[index];
	}

/** Resolves classes by ID or by fully qualified class name.
 1. @author Nathan Sweet <misc@n4te.com> */
public class DefaultClassResolver implements ClassResolver {
	static public final byte NAME = -1;

	protected Kryo kryo;
	/**
	 * id获取注册对象
	 */
	protected final IntMap<Registration> idToRegistration = new IntMap();
	/**
	 * class类型获取注册对象
	 */
	protected final ObjectMap<Class, Registration> classToRegistration = new ObjectMap();

	/**
	 * class、nameId缓存
	 */
	protected IdentityObjectIntMap<Class> classToNameId;
	/**
	 * nameId、class缓存
	 */
	protected IntMap<Class> nameIdToClass;
	/**
	 * name、class的缓存
	 */
	protected ObjectMap<String, Class> nameToClass;

	/**
	 * name的id
	 */
	protected int nextNameId;

	/**
	 * 缓存classId
	 */
	private int memoizedClassId = -1;
	/**
	 * 缓存classId注册对象
	 */
	private Registration memoizedClassIdValue;
	//缓存中的class
	private Class memoizedClass;
	//缓存中的class注册对象
	private Registration memoizedClassValue;

	public void setKryo (Kryo kryo) {
		this.kryo = kryo;
	}

	/**
	 *
	 * @param registration
	 * @return
	 */
	public Registration register (Registration registration) {
		if (registration == null) throw new IllegalArgumentException("registration cannot be null.");
		//非原始name值
		if (registration.getId() != NAME) {
			if (TRACE) {
				trace("kryo", "Register class ID " + registration.getId() + ": " + className(registration.getType()) + " ("
					+ registration.getSerializer().getClass().getName() + ")");
			}
			//根据id存入注册对象
			idToRegistration.put(registration.getId(), registration);
		} else if (TRACE) {
			trace("kryo", "Register class name: " + className(registration.getType()) + " ("
				+ registration.getSerializer().getClass().getName() + ")");
		}
		//根据class存入注册对象
		classToRegistration.put(registration.getType(), registration);
		if (registration.getType().isPrimitive()) classToRegistration.put(getWrapperClass(registration.getType()), registration);
		return registration;
	}

	public Registration registerImplicit (Class type) {
		return register(new Registration(type, kryo.getDefaultSerializer(type), NAME));
	}

	public Registration getRegistration (Class type) {
		//直接获取缓存注册对象
		if (type == memoizedClass) return memoizedClassValue;
		//全局状态下，直接获取注册对象
		Registration registration = classToRegistration.get(type);
		if (registration != null) {
			memoizedClass = type;
			memoizedClassValue = registration;
		}
		return registration;
	}

	public Registration getRegistration (int classID) {
		return idToRegistration.get(classID);
	}

	/**
	 * 根据class write操作
	 * @param output
	 * @param type May be null.
	 * @return
	 */
	public Registration writeClass (Output output, Class type) {
		if (type == null) {
			if (TRACE || (DEBUG && kryo.getDepth() == 1)) log("Write", null);
			//null对象的缓存byte存储的位置
			output.writeVarInt(Kryo.NULL, true);
			return null;
		}
		//获取注册对象
		Registration registration = kryo.getRegistration(type);
		//第1次write
		if (registration.getId() == NAME)
			//没有classId，根据name获取注册对象
			writeName(output, type, registration);
		else {//非第1次，写入classId
			if (TRACE) trace("kryo", "Write class " + registration.getId() + ": " + className(type));
			output.writeVarInt(registration.getId() + 2, true);
		}
		return registration;
	}

	/**
	 * 根据name write操作
	 * @param output
	 * @param type
	 * @param registration
	 */
	protected void writeName (Output output, Class type, Registration registration) {
		output.writeVarInt(NAME + 2, true);
		//有缓存
		if (classToNameId != null) {
			//根据class获取nameId
			int nameId = classToNameId.get(type, -1);
			if (nameId != -1) {
				if (TRACE) trace("kryo", "Write class name reference " + nameId + ": " + className(type));
				output.writeVarInt(nameId, true);
				return;
			}
		}
		// Only write the class name the first time encountered in object graph.
		if (TRACE) trace("kryo", "Write class name: " + className(type));
		//new nameId
		int nameId = nextNameId++;
		if (classToNameId == null) classToNameId = new IdentityObjectIntMap();
		//class、nameId存入缓存
		classToNameId.put(type, nameId);
		output.writeVarInt(nameId, true);
		output.writeString(type.getName());
	}

	/**
	 * 读取class
	 * @param input
	 * @return
	 */
	public Registration readClass (Input input) {
		//获取class的id标识
		int classID = input.readVarInt(true);
		switch (classID) {
		case Kryo.NULL:
			if (TRACE || (DEBUG && kryo.getDepth() == 1)) log("Read", null);
			return null;
		case NAME + 2: // Offset for NAME and NULL.
			//classId实际上就是nameId，根据nameId获取对象
			return readName(input);
		}
		if (classID == memoizedClassId) return memoizedClassIdValue;
		//class的注册对象
		Registration registration = idToRegistration.get(classID - 2);
		if (registration == null) throw new KryoException("Encountered unregistered class ID: " + (classID - 2));
		if (TRACE) trace("kryo", "Read class " + (classID - 2) + ": " + className(registration.getType()));
		//新的classId、注册对象赋值到缓存变量
		memoizedClassId = classID;
		memoizedClassIdValue = registration;
		return registration;
	}

	/**
	 * 读取class name
	 * @param input
	 * @return
	 */
	protected Registration readName (Input input) {
		int nameId = input.readVarInt(true);
		//缓存
		if (nameIdToClass == null) nameIdToClass = new IntMap();
		//根据nameId获取class
		Class type = nameIdToClass.get(nameId);
		if (type == null) {
			// Only read the class name the first time encountered in object graph.
			String className = input.readString();
			type = getTypeByName(className);
			//class is null,通过反射获取class
			if (type == null) {
				try {
					type = Class.forName(className, false, kryo.getClassLoader());
				} catch (ClassNotFoundException ex) {
					if (WARN) warn("kryo", "Unable to load class " + className + " with kryo's ClassLoader. Retrying with current..");
					try {
						type = Class.forName(className);
					} catch (ClassNotFoundException e) {
						throw new KryoException("Unable to find class: " + className, ex);
					}
				}

				if (nameToClass == null) nameToClass = new ObjectMap();
				//根据class存入缓存
				nameToClass.put(className, type);
			}
			//根据nameId存入缓存中
			nameIdToClass.put(nameId, type);
			if (TRACE) trace("kryo", "Read class name: " + className);
		} else {
			if (TRACE) trace("kryo", "Read class name reference " + nameId + ": " + className(type));
		}
		return kryo.getRegistration(type);
	}

	protected Class<?> getTypeByName (final String className) {
		return nameToClass != null ? nameToClass.get(className) : null;
	}

	public void reset () {
		if (!kryo.isRegistrationRequired()) {
			if (classToNameId != null) classToNameId.clear();
			if (nameIdToClass != null) nameIdToClass.clear();
			nextNameId = 0;
		}
	}
}

/** Writes a 1-5 byte int. It is guaranteed that a varible length encoding will be used.
	 * 
	 * @param optimizePositive If true, small positive numbers will be more efficient (1 byte) and small negative numbers will be
	 *           inefficient (5 bytes). */
	public int writeVarInt (int value, boolean optimizePositive) throws KryoException {
		if (!optimizePositive) value = (value << 1) ^ (value >> 31);
		if (value >>> 7 == 0) {
			require(1);
			buffer[position++] = (byte)value;
			return 1;
		}
		if (value >>> 14 == 0) {
			require(2);
			buffer[position++] = (byte)((value & 0x7F) | 0x80);
			buffer[position++] = (byte)(value >>> 7);
			return 2;
		}
		if (value >>> 21 == 0) {
			require(3);
			buffer[position++] = (byte)((value & 0x7F) | 0x80);
			buffer[position++] = (byte)(value >>> 7 | 0x80);
			buffer[position++] = (byte)(value >>> 14);
			return 3;
		}
		if (value >>> 28 == 0) {
			require(4);
			buffer[position++] = (byte)((value & 0x7F) | 0x80);
			buffer[position++] = (byte)(value >>> 7 | 0x80);
			buffer[position++] = (byte)(value >>> 14 | 0x80);
			buffer[position++] = (byte)(value >>> 21);
			return 4;
		}
		//需要5个字节的空间
		require(5);
		buffer[position++] = (byte)((value & 0x7F) | 0x80);
		buffer[position++] = (byte)(value >>> 7 | 0x80);
		buffer[position++] = (byte)(value >>> 14 | 0x80);
		buffer[position++] = (byte)(value >>> 21 | 0x80);
		buffer[position++] = (byte)(value >>> 28);
		//返回byte[]的长度
		return 5;
	}

/** @return true if the buffer has been resized. */
	//重置数组的长度
	protected boolean require (int required) throws KryoException {
		if (capacity - position >= required) return false;
		if (required > maxCapacity)
			throw new KryoException("Buffer overflow. Max capacity: " + maxCapacity + ", required: " + required);
		flush();
		while (capacity - position < required) {
			if (capacity == maxCapacity)
				throw new KryoException("Buffer overflow. Available: " + (capacity - position) + ", required: " + required);
			// Grow buffer.
			if (capacity == 0) capacity = 1;
			capacity = Math.min(capacity * 2, maxCapacity);
			if (capacity < 0) capacity = maxCapacity;
			byte[] newBuffer = new byte[capacity];
			System.arraycopy(buffer, 0, newBuffer, 0, position);
			buffer = newBuffer;
		}
		return true;
	}

/** Serializes objects using Java's built in serialization mechanism. Note that this is very inefficient and should be avoided if
 * possible.
 * @see Serializer
 * @see FieldSerializer
 * @see KryoSerializable
 * @author Nathan Sweet <misc@n4te.com> */
public class JavaSerializer extends Serializer {
	public void write (Kryo kryo, Output output, Object object) {
		try {
			ObjectMap graphContext = kryo.getGraphContext();
			ObjectOutputStream objectStream = (ObjectOutputStream)graphContext.get(this);
			if (objectStream == null) {
				objectStream = new ObjectOutputStream(output);
				graphContext.put(this, objectStream);
			}
			objectStream.writeObject(object);
			objectStream.flush();
		} catch (Exception ex) {
			throw new KryoException("Error during Java serialization.", ex);
		}
	}

	public Object read (Kryo kryo, Input input, Class type) {
		try {
			ObjectMap graphContext = kryo.getGraphContext();
			ObjectInputStream objectStream = (ObjectInputStream)graphContext.get(this);
			if (objectStream == null) {
				objectStream = new ObjectInputStreamWithKryoClassLoader(input, kryo);
				graphContext.put(this, objectStream);
			}
			return objectStream.readObject();
		} catch (Exception ex) {
			throw new KryoException("Error during Java deserialization.", ex);
		}
	}

	/**
	 * ${@link ObjectInputStream} uses the last user-defined ${@link ClassLoader} which may not be the correct one.
		* This is a known Java issue and is often solved by using a specific class loader.
	 * See:
	 * https://github.com/apache/spark/blob/v1.6.3/streaming/src/main/scala/org/apache/spark/streaming/Checkpoint.scala#L154
	 * https://issues.apache.org/jira/browse/GROOVY-1627
	 */
	private static class ObjectInputStreamWithKryoClassLoader extends ObjectInputStream {
		private final ClassLoader loader;

		ObjectInputStreamWithKryoClassLoader(InputStream in, Kryo kryo) throws IOException {
			super(in);
			this.loader = kryo.getClassLoader();
		}

		@Override
		protected Class<?> resolveClass(ObjectStreamClass desc) {
			try {
				return Class.forName(desc.getName(), false, loader);
			} catch (ClassNotFoundException e) {
				throw new RuntimeException("Class not found: " + desc.getName(), e);
			}
		}
	}
}

/** Serializes objects that implement the {@link Map} interface.
 * <p>
 * With the default constructor, a map requires a 1-3 byte header and an extra 4 bytes is written for each key/value pair.
 * @author Nathan Sweet <misc@n4te.com> */
public class MapSerializer extends Serializer<Map> {
	private Class keyClass, valueClass;
	private Serializer keySerializer, valueSerializer;
	private boolean keysCanBeNull = true, valuesCanBeNull = true;
	private Class keyGenericType, valueGenericType;

	....

	/**
	 * 设置泛型
	 * @param kryo
	 * @param generics Some (but never all) elements may be null if there is no generic type information at that index.
	 */
	public void setGenerics (Kryo kryo, Class[] generics) {
		keyGenericType = null;
		valueGenericType = null;

		if (generics != null && generics.length > 0) {
			if (generics[0] != null && kryo.isFinal(generics[0])) keyGenericType = generics[0];
			if (generics.length > 1 && generics[1] != null && kryo.isFinal(generics[1])) valueGenericType = generics[1];
		}
	}

	public void write (Kryo kryo, Output output, Map map) {
		int length = map.size();
		//写入Map的长度到缓存中
		output.writeInt(length, true);

		Serializer keySerializer = this.keySerializer;
		//泛型
		if (keyGenericType != null) {
			if (keySerializer == null) keySerializer = kryo.getSerializer(keyGenericType);
			keyGenericType = null;
		}
		Serializer valueSerializer = this.valueSerializer;
		if (valueGenericType != null) {
			if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueGenericType);
			valueGenericType = null;
		}

		//遍历map
		for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
			Entry entry = (Entry)iter.next();

			//写入key的序列化对象值
			if (keySerializer != null) {
				if (keysCanBeNull)
					kryo.writeObjectOrNull(output, entry.getKey(), keySerializer);
				else
					kryo.writeObject(output, entry.getKey(), keySerializer);
			} else
				kryo.writeClassAndObject(output, entry.getKey());

			//写入value的序列化对象值
			if (valueSerializer != null) {
				if (valuesCanBeNull)
					kryo.writeObjectOrNull(output, entry.getValue(), valueSerializer);
				else
					kryo.writeObject(output, entry.getValue(), valueSerializer);
			} else
				kryo.writeClassAndObject(output, entry.getValue());
		}
	}

	/** Used by {@link #read(Kryo, Input, Class)} to create the new object. This can be overridden to customize object creation, eg
	 * to call a constructor with arguments. The default implementation uses {@link Kryo#newInstance(Class)}. */
	protected Map create (Kryo kryo, Input input, Class<Map> type) {
		return kryo.newInstance(type);
	}

	public Map read (Kryo kryo, Input input, Class<Map> type) {
		Map map = create(kryo, input, type);
		//读取Map的长度
		int length = input.readInt(true);

		Class keyClass = this.keyClass;
		Class valueClass = this.valueClass;

		Serializer keySerializer = this.keySerializer;
		if (keyGenericType != null) {
			keyClass = keyGenericType;
			if (keySerializer == null) keySerializer = kryo.getSerializer(keyClass);
			keyGenericType = null;
		}
		Serializer valueSerializer = this.valueSerializer;
		if (valueGenericType != null) {
			valueClass = valueGenericType;
			if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueClass);
			valueGenericType = null;
		}

		kryo.reference(map);

		for (int i = 0; i < length; i++) {
			Object key;

			if (keySerializer != null) {
				if (keysCanBeNull)
					key = kryo.readObjectOrNull(input, keyClass, keySerializer);
				else
					key = kryo.readObject(input, keyClass, keySerializer);
			} else
				key = kryo.readClassAndObject(input);
			Object value;
			if (valueSerializer != null) {
				if (valuesCanBeNull)
					value = kryo.readObjectOrNull(input, valueClass, valueSerializer);
				else
					value = kryo.readObject(input, valueClass, valueSerializer);
			} else
				value = kryo.readClassAndObject(input);
			map.put(key, value);
		}
		return map;
	}

	protected Map createCopy (Kryo kryo, Map original) {
		return kryo.newInstance(original.getClass());
	}

	public Map copy (Kryo kryo, Map original) {
		Map copy = createCopy(kryo, original);
		for (Iterator iter = original.entrySet().iterator(); iter.hasNext();) {
			Entry entry = (Entry)iter.next();
			copy.put(kryo.copy(entry.getKey()), kryo.copy(entry.getValue()));
		}
		return copy;
	}

	/** Used to annotate fields that are maps with specific Kryo serializers for their keys or values. */
	@Retention(RetentionPolicy.RUNTIME)
	@Target(ElementType.FIELD)
	public @interface BindMap {

		/** Serializer to be used for keys
		 * 
		 * @return the class<? extends serializer> used for keys serialization */
		@SuppressWarnings("rawtypes")
		Class<? extends Serializer> keySerializer() default Serializer.class;

		/** Serializer to be used for values
		 * 
		 * @return the class<? extends serializer> used for values serialization */
		@SuppressWarnings("rawtypes")
		Class<? extends Serializer> valueSerializer() default Serializer.class;

		/** Class used for keys
		 * 
		 * @return the class used for keys */
		Class<?> keyClass() default Object.class;

		/** Class used for values
		 * 
		 * @return the class used for values */
		Class<?> valueClass() default Object.class;

		/** Indicates if keys can be null
		 * 
		 * @return true, if keys can be null */
		boolean keysCanBeNull() default true;

		/** Indicates if values can be null
		 * 
		 * @return true, if values can be null */
		boolean valuesCanBeNull() default true;
	}
}

/** Reads the class and object or null using the registered serializer.
	 * @return May be null. */
	public Object readClassAndObject (Input input) {
		if (input == null) throw new IllegalArgumentException("input cannot be null.");
		beginObject();
		try {
			//先读取class的注册对象
			Registration registration = readClass(input);
			if (registration == null) return null;
			Class type = registration.getType();

			Object object;
			//有引用
			if (references) {
				//设置泛型
				registration.getSerializer().setGenerics(this, null);
				//返回对象id
				int stackSize = readReferenceOrNull(input, type, false);
                //基本类型和第1次读取对象，返回readReferenceIds.size()
				if (stackSize == REF) return readObject;
				//直接Serializer实现类中获取readObject
				object = registration.getSerializer().read(this, input, type);
				//id=id数组的长度,存储到缓存中
				if (stackSize == readReferenceIds.size) reference(object);
			} else//从实现的Serializer中读取对象
				object = registration.getSerializer().read(this, input, type);
			if (TRACE || (DEBUG && depth == 1)) log("Read", object);
			return object;
		} finally {
			if (--depth == 0 && autoReset) reset();
		}
	}

/** Returns {@link #REF} if a reference to a previously read object was read, which is stored in {@link #readObject}. Returns a
	 * stack size (> 0) if a reference ID has been put on the stack. */
	//读取readobject或者是null
	int readReferenceOrNull (Input input, Class type, boolean mayBeNull) {
		//基本数据类型
		if (type.isPrimitive()) type = getWrapperClass(type);
		//是否支持引用类型
		boolean referencesSupported = referenceResolver.useReferences(type);
		int id;
		//允许null
		if (mayBeNull) {
			//获取当前对象的id
			id = input.readVarInt(true);
			//当前id对应的对象值是null
			if (id == Kryo.NULL) {
				if (TRACE || (DEBUG && depth == 1)) log("Read", null);
				readObject = null;
				//返回对象引用
				return REF;
			}
			//对象!=null，基本数据类型，添加到id数组中
			if (!referencesSupported) {
				readReferenceIds.add(NO_REF);
				return readReferenceIds.size;
			}
		} else {//not null
			//基本类型
			if (!referencesSupported) {
				//添加基本类型的id
				readReferenceIds.add(NO_REF);
				return readReferenceIds.size;
			}
			//引用读取byte[]缓存，返回id值
			id = input.readVarInt(true);
		}
		//id对应的引用对象!=null，第1次读取，存入read的id数组
		if (id == NOT_NULL) {
			// First time object has been encountered.
			//id递增
			//这里的id是read的reference数组的id
			id = referenceResolver.nextReadId(type);
			if (TRACE) trace("kryo", "Read initial object reference " + id + ": " + className(type));
			//添加到read的reference数组中
			readReferenceIds.add(id);
            //id值就是readReferenceIds.size
			return readReferenceIds.size;
		}
		// The id is an object reference.id == NULL
		id -= 2; // - 2 because 0 and 1 are used for NULL and NOT_NULL.
		//默认从MapReferenceResolver中获取object
		readObject = referenceResolver.getReadObject(type, id);
		if (DEBUG) debug("kryo", "Read object reference " + id + ": " + string(readObject));
		return REF;
	}