public final V get() {
    // #1
	InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
	// #2
	Object v = threadLocalMap.indexedVariable(index);
	if (v != InternalThreadLocalMap.UNSET) {
		return (V) v;
	}
    // #3
	return initialize(threadLocalMap);
}

#1 获取该线程的InternalThreadLocalMap
如果是FastThreadLocalThread，直接获取FastThreadLocalThread#threadLocalMap。
否则，从UnpaddedInternalThreadLocalMap.slowThreadLocalMap获取该线程InternalThreadLocalMap。
注意，UnpaddedInternalThreadLocalMap.slowThreadLocalMap是一个ThreadLocal，这里实际回退到使用ThreadLocal了。
#2 每个FastThreadLocal都有一个index。
通过该index，获取InternalThreadLocalMap#indexedVariables中存放的值
#3 找不到值，通过initialize方法构建新对象。

可以看到，FastThreadLocal中连hash算法都不用，通过下标获取对应的值，复杂度为log(1)，自然很快啦。

HashedWheelTimer

HashedWheelTimer是Netty提供的时间轮调度器。
时间轮是一种充分利用线程资源进行批量化任务调度的调度模型，能够高效的管理各种延时任务。
简单说，就是将延时任务存放到一个环形队列中，并通过执行线程定时执行该队列的任务。

例如，
环形队列上有60个格子，
执行线程每秒移动一个格子，则环形队列每轮可存放1分钟内的任务。
现在有两个定时任务
task1，32秒后执行
task2，2分25秒后执行
而执行线程当前位于第6格子
则task1放到32+6=38格，轮数为0
task2放到25+6=31个，轮数为2
执行线程将执行当前格子轮数为0的任务，并将其他任务轮数减1。

缺点，时间轮调度器的时间精度不高。
因为时间轮算法的精度取决于执行线程移动速度。
例如上面例子中执行线程每秒移动一个格子，则调度精度小于一秒的任务就无法准时调用。

HashedWheelTimer关键字段

// 任务执行器，负责执行任务
Worker worker = new Worker();
// 任务执行线程
Thread workerThread;
//  HashedWheelTimer状态， 0 - init, 1 - started, 2 - shut down
int workerState;
// 时间轮队列，使用数组实现
HashedWheelBucket[] wheel;
// 暂存新增的任务
Queue<HashedWheelTimeout> timeouts = PlatformDependent.newMpscQueue();
// 已取消任务
Queue<HashedWheelTimeout> cancelledTimeouts = PlatformDependent.newMpscQueue();

public Timeout newTimeout(TimerTask task, long delay, TimeUnit unit) {
    ...

    // #1
    start();

    // #2
    long deadline = System.nanoTime() + unit.toNanos(delay) - startTime;

    ...
    HashedWheelTimeout timeout = new HashedWheelTimeout(this, task, deadline);
    timeouts.add(timeout);
    return timeout;
}

public void run() {
	...

	// #1
	startTimeInitialized.countDown();

	do {
		// #2
		final long deadline = waitForNextTick();
		if (deadline > 0) {
			// #3
			int idx = (int) (tick & mask);
			processCancelledTasks();
			HashedWheelBucket bucket = wheel[idx];
			// #4
			transferTimeoutsToBuckets();
			// #5
			bucket.expireTimeouts(deadline);
			// #6
			tick++;
		}
	} while (WORKER_STATE_UPDATER.get(HashedWheelTimer.this) == WORKER_STATE_STARTED);

    // #7
	...
}

private void transferTimeoutsToBuckets() {
	// #1
	for (int i = 0; i < 100000; i++) {
		HashedWheelTimeout timeout = timeouts.poll();
		if (timeout == null) {
			// all processed
			break;
		}
		if (timeout.state() == HashedWheelTimeout.ST_CANCELLED) {
			continue;
		}
		// #2
		long calculated = timeout.deadline / tickDuration;
		// #3
		timeout.remainingRounds = (calculated - tick) / wheel.length;
		// #4
		final long ticks = Math.max(calculated, tick); // Ensure we don't schedule for past.
		// #5
		int stopIndex = (int) (ticks & mask);

		HashedWheelBucket bucket = wheel[stopIndex];
		bucket.addTimeout(timeout);
	}
}

public void expireTimeouts(long deadline) {
	HashedWheelTimeout timeout = head;

	while (timeout != null) {
		HashedWheelTimeout next = timeout.next;
		// #1
		if (timeout.remainingRounds <= 0) {
			// #2
			next = remove(timeout);
			if (timeout.deadline <= deadline) {
				// #3
				timeout.expire();
			} else {
				throw new IllegalStateException(String.format(
						"timeout.deadline (%d) > deadline (%d)", timeout.deadline, deadline));
			}
		} else if (timeout.isCancelled()) {
			next = remove(timeout);
		} else {
			// #4
			timeout.remainingRounds --;
		}
		timeout = next;
	}
}