TimeZone.getDefault()

@JsonDeserialize(using = CustomJsonDateDeserializer.class)
private Date operateStartDate;

public class CustomJsonDateDeserializer extends JsonDeserializer<Date> {
    @Override
    public Date deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date = jp.getText();
        try {
            return format.parse(date);
        } catch (ParseException e1) {
            throw new RuntimeException(e1);
        }
    }
}

@JsonSerialize(using = CustomJsonDateSerializer.class)
private Date create_time;

public class CustomJsonDateSerializer extends JsonSerializer<Date> {

    @Override
    public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            String dateString = dateFormat.format(date);
            jsonGenerator.writeString(dateString);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

private void fixAfterInsertion(Entry<K, V> x) {
	x.color = RED;

	while (x != null && x != root && x.parent.color == RED) {
		// 如果是父节点是黑色的话，则不会改变红黑树性质，不做调整。如果父节点则说明无法满足性质，需要调整。
		if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
			// 父节点是祖父节点做子节点。else里和此对应。
			// 获取叔父节点
			Entry<K, V> y = rightOf(parentOf(parentOf(x)));
			if (colorOf(y) == RED) {
				// 情形3
				setColor(parentOf(x), BLACK);
				setColor(y, BLACK);
				setColor(parentOf(parentOf(x)), RED);
				x = parentOf(parentOf(x));
			} else {
				if (x == rightOf(parentOf(x))) {
					// 情形4（此情形是为5服务的）
					x = parentOf(x);
					// 左旋
					rotateLeft(x);
				}
				// 情形5，
				setColor(parentOf(x), BLACK);
				setColor(parentOf(parentOf(x)), RED);
				// 右旋，右旋的意义在于不改变平衡树和红黑树性质的情况下，把一个红色转移到另一子树中。应为子树不会影响性质。
				rotateRight(parentOf(parentOf(x)));
			}
		} else {
			// 与if内容类似，只是更改了左右方向。
			Entry<K, V> y = leftOf(parentOf(parentOf(x)));
			if (colorOf(y) == RED) {
				setColor(parentOf(x), BLACK);
				setColor(y, BLACK);
				setColor(parentOf(parentOf(x)), RED);
				x = parentOf(parentOf(x));
			} else {
				if (x == leftOf(parentOf(x))) {
					x = parentOf(x);
					rotateRight(x);
				}
				setColor(parentOf(x), BLACK);
				setColor(parentOf(parentOf(x)), RED);
				rotateLeft(parentOf(parentOf(x)));
			}
		}
	}
	root.color = BLACK;
}

private void deleteEntry(Entry<K, V> p) {
	modCount++;
	size--;

	// If strictly internal, copy successor's element to p and then make p
	// point to successor.
	// 如果有两个子节点，则获取后继，然后将后继的节点的内容拷贝至p中，接下来要处理的就变成后继节点。
	if (p.left != null && p.right != null) {
		Entry<K, V> s = successor(p);
		p.key = s.key;
		p.value = s.value;
		p = s;
	} // p has 2 children

	// Start fixup at replacement node, if it exists.
	/**
	 *  在这个时候我们可以保证的是，p节点最多只有一个子节点。分为三种情况。
	 *  1. 有一个节点
	 *  2. 此节点为ROOT
	 *  3. 没有子节点
	 *  此外，我们需要做当节点是黑色时 ，我们需要进行旋转，因为删除黑色会改变红黑树的性质。
	 */
	
	Entry<K, V> replacement = (p.left != null ? p.left : p.right);

	if (replacement != null) {
		// 1. 有一个节点
		// Link replacement to parent
		// 将replacement替换给节点p，替换之后，我们就少了一个节点，如果的节点p是黑色，我们需要做些调整。
		replacement.parent = p.parent;
		if (p.parent == null)
			root = replacement;
		else if (p == p.parent.left)
			p.parent.left = replacement;
		else
			p.parent.right = replacement;

		// Null out links so they are OK to use by fixAfterDeletion.
		p.left = p.right = p.parent = null;

		// Fix replacement
		if (p.color == BLACK)
			fixAfterDeletion(replacement);
	} else if (p.parent == null) { // return if we are the only node.
		// 2. 此节点为ROOT
		root = null;
	} else { // No children. Use self as phantom replacement and unlink.
		// 3. 没有子节点
		// 节点p是的黑色的话，需要做调整，然后才能把节点p移除。
		if (p.color == BLACK)
			fixAfterDeletion(p);
		// 解除掉节点p
		if (p.parent != null) {
			if (p == p.parent.left)
				p.parent.left = null;
			else if (p == p.parent.right)
				p.parent.right = null;
			p.parent = null;
		}
	}
}

/** From CLR
 * 
 *  x 节点需要调整，x节点的路径少了个黑色节点，需要平衡。
 *  	1. x下面的有一个黑色节点删除。
 *  	2. x会被删除，x是黑色。
 *  
 *  */
private void fixAfterDeletion(Entry<K, V> x) {
	while (x != root && colorOf(x) == BLACK) {
		if (x == leftOf(parentOf(x))) {
			Entry<K, V> sib = rightOf(parentOf(x));

			if (colorOf(sib) == RED) {
				// 情形2
				setColor(sib, BLACK);
				setColor(parentOf(x), RED);
				rotateLeft(parentOf(x));
				sib = rightOf(parentOf(x));
			}
			// 到此为止，sib变为黑色
			if (colorOf(leftOf(sib)) == BLACK && colorOf(rightOf(sib)) == BLACK) {
				// 情形3
				setColor(sib, RED);
				x = parentOf(x);
			} else {
				if (colorOf(rightOf(sib)) == BLACK) {
					// 情形5
					setColor(leftOf(sib), BLACK);
					setColor(sib, RED);
					rotateRight(sib);
					sib = rightOf(parentOf(x));
				}
				// 情形6
				setColor(sib, colorOf(parentOf(x)));
				setColor(parentOf(x), BLACK);
				setColor(rightOf(sib), BLACK);
				rotateLeft(parentOf(x));
				x = root;  // 可以终止算法，说明这种情形是我们最终的想要的。
			}
		} else { // symmetric
			...
		}
	}

	setColor(x, BLACK);
}

writeEntry = doWALAppend(walEdit, batchOp.durability, batchOp.getClusterIds(), now,
             nonceKey.getNonceGroup(), nonceKey.getNonce(), batchOp.getOrigLogSeqNum());

long txid = this.wal.append(this.getRegionInfo(), walKey, walEdit, true);
   // Call sync on our edit.
   if (txid != 0) {
     sync(txid, durability);
   }

synchronized long get(long timeoutNs) throws InterruptedException,
      ExecutionException, TimeoutIOException {
    final long done = System.nanoTime() + timeoutNs;
    while (!isDone()) {
      wait(1000);
      if (System.nanoTime() >= done) {
        throw new TimeoutIOException(
            "Failed to get sync result after " + TimeUnit.NANOSECONDS.toMillis(timeoutNs)
                + " ms for txid=" + this.txid + ", WAL system stuck?");
      }
    }
    if (this.throwable != null) {
      throw new ExecutionException(this.throwable);
    }
    return this.doneTxid;
  }

synchronized boolean isDone() {
  return this.doneTxid != NOT_DONE;
}

if (truck.type() == RingBufferTruck.Type.SYNC) {
        // 给syncFutures其中一个设置。
        this.syncFutures[this.syncFuturesCount.getAndIncrement()] = truck.unloadSync();
        // Force flush of syncs if we are carrying a full complement of syncFutures.
        if (this.syncFuturesCount.get() == this.syncFutures.length) {
          endOfBatch = true;
        }
      } else if (truck.type() == RingBufferTruck.Type.APPEND) {
        FSWALEntry entry = truck.unloadAppend();
        try {
	...
          append(entry);
        } catch (Exception e) {
          ....
          return;
        }
      }

if (!endOfBatch || this.syncFuturesCount.get() <= 0) {
        return;
      }
      this.syncRunnerIndex = (this.syncRunnerIndex + 1) % this.syncRunners.length;
      try {
        // 给syncRunners其中一个设置，在offer方法内，将下标小于syncFuturesCount的所有syncFutures传递给其中一个的SyncRunners。
        // 下标小于syncFuturesCount的所有syncFutures都传递过去其实就代表了一个batch，这个逻辑可以通过endOfBatch捋出来。 *** 此处很重要 ***
        this.syncRunners[this.syncRunnerIndex].offer(sequence, this.syncFutures,
          this.syncFuturesCount.get());
      } catch (Exception e) {
        // Should NEVER get here.
        requestLogRoll();
        this.exception = new DamagedWALException("Failed offering sync", e);
      }
....
      this.syncFuturesCount.set(0);

   while (!isInterrupted()) {
     int syncCount = 0;

     try {
       // 获取需要执行sync的场景
       while (true) {
         takeSyncFuture = null;
         // We have to process what we 'take' from the queue
         takeSyncFuture = this.syncFutures.take();
         currentSequence = this.sequence;
         long syncFutureSequence = takeSyncFuture.getTxid();
         if (syncFutureSequence > currentSequence) {
           throw new IllegalStateException("currentSequence=" + currentSequence
               + ", syncFutureSequence=" + syncFutureSequence);
         }
         // See if we can process any syncfutures BEFORE we go sync.
         // 掠过一些已经sync过的sequence，可能在别syncRunner已经执行过了，或当时多加的部分。
         long currentHighestSyncedSequence = highestSyncedTxid.get();
         if (currentSequence < currentHighestSyncedSequence) {
           syncCount += releaseSyncFuture(takeSyncFuture, currentHighestSyncedSequence, null);
           // Done with the 'take'. Go around again and do a new 'take'.
           continue;
         }
         break;
       }
       try {
         // 执行sync
         writer.sync(useHsync);
         // 更新highestSyncedTxid，此处记录了目前sync的最高Sequence。
         currentSequence = updateHighestSyncedSequence(currentSequence);
       } catch (IOException e) {
...
       } finally {
         // First release what we 'took' from the queue.
         // release目前取到的SyncFuture。
         syncCount += releaseSyncFuture(takeSyncFuture, currentSequence, lastException);
         // Can we release other syncs?
         // release所有目前小于当前sequence的SyncFuture。这步感觉好像是没有必要的。
         syncCount += releaseSyncFutures(currentSequence, lastException);
         if (lastException != null) {
           requestLogRoll();
         } else {
           checkLogRoll();
         }
       }
       postSync(System.nanoTime() - start, syncCount);
     } catch (InterruptedException e) {
       ...
     }
   }