知識星球摘自【工匠小豬豬的技術世界】 1.這是一個系列，有興趣的朋友可以持續關註 2.如果你有HikariCP使用上的問題，可以給我留言，我們一起溝通討論 3.希望大家可以提供我一些案例，我也希望可以支援你們做一些調優
概述
在Down-the-Rabbit-Hole中，作者提到了一些 Micro-optimizations，表達了作者追求極致的態度。
HikariCP contains many micro-optimizations that individually are barely measurable, but together combine as a boost to overall performance. Some of these optimizations are measured in fractions of a millisecond amortized over millions of invocations.
其中第一條就提到了ArrayList的最佳化
One non-trivial (performance-wise) optimization was eliminating the use of an ArrayList instance in the ConnectionProxy used to track open Statement instances. When a Statement is closed, it must be removed from this collection, and when the Connection is closed it must iterate the collection and close any open Statement instances, and finally must clear the collection. The Java ArrayList, wisely for general purpose use, performs a range check upon every get(int index) call. However, because we can provide guarantees about our ranges, this check is merely overhead.
Additionally, the remove(Object) implementation performs a scan from head to tail, however common patterns in JDBC programming are to close Statements immediately after use, or in reverse order of opening. For these cases, a scan that starts at the tail will perform better. Therefore, ArrayList was replaced with a custom class FastList which eliminates range checking and performs removal scans from tail to head.
FastList是一個List介面的精簡實現，只實現了介面中必要的幾個方法。JDK ArrayList每次呼叫get()方法時都會進行rangeCheck檢查索引是否越界，FastList的實現中去除了這一檢查，只要保證索引合法那麼rangeCheck就成為了不必要的計算開銷(當然開銷極小)。此外，HikariCP使用List來儲存開啟的Statement，當Statement關閉或Connection關閉時需要將對應的Statement從List中移除。通常情況下，同一個Connection建立了多個Statement時，後開啟的Statement會先關閉。ArrayList的remove(Object)方法是從頭開始遍歷陣列，而FastList是從陣列的尾部開始遍歷，因此更為高效。
簡而言之就是 自定義陣列型別（FastList）代替ArrayList：避免每次get()呼叫都要進行range check，避免呼叫remove()時的從頭到尾的掃描
原始碼分析
java.util.ArrayList
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializablecode>
com.zaxxer.hikari.util.FastList
<code class="">public final class FastList<T> implements List<T>, RandomAccess, Serializable
我們先看一下java.util.ArrayList的get方法
/**
* Returns the element at the specified position in this list.
*
* @param index index of the element to return
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
我們可以看到每次get的時候都會進行rangeCheck
/**
* Checks if the given index is in range. If not, throws an appropriate
* runtime exception. This method does *not* check if the index is
* negative: It is always used immediately prior to an array access,
* which throws an ArrayIndexOutOfBoundsException if index is negative.
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
我們對比一下com.zaxxer.hikari.util.FastList的get方法，可以看到取消了rangeCheck，一定程度下追求了極致
/**
* Get the element at the specified index.
*
* @param index the index of the element to get
* @return the element, or ArrayIndexOutOfBounds is thrown if the index is invalid
*/
@Override
public T get(int index) {
return elementData[index];
}
我們再來看一下ArrayList的remove(Object)方法
/**
* Removes the first occurrence of the specified element from this list,
* if it is present. If the list does not contain the element, it is
* unchanged. More formally, removes the element with the lowest index
* i such that
* (o==null ? get(i)==null : o.equals(get(i)))
* (if such an element exists). Returns true if this list
* contained the specified element (or equivalently, if this list
* changed as a result of the call).
*
* @param o element to be removed from this list, if present
* @return true if this list contained the specified element
*/
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
再對比看一下FastList的remove(Object方法)
/**
* This remove method is most efficient when the element being removed
* is the last element. Equality is identity based, not equals() based.
* Only the first matching element is removed.
*
* @param element the element to remove
*/
@Override
public boolean remove(Object element) {
for (int index = size - 1; index >= 0; index--) {
if (element == elementData[index]) {
final int numMoved = size - index - 1;
if (numMoved > 0) {
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
}
elementData[--size] = null;
return true;
}
}
return false;
}
好了，今天的文章就是這麼簡短，最後附一下FastList的原始碼，內容真的是十分精簡的。
/*
* Copyright (C) 2013, 2014 Brett Wooldridge
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zaxxer.hikari.util;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.RandomAccess;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
/**
* Fast list without range checking.
*
* @author Brett Wooldridge
*/
public final class FastList<T> implements List<T>, RandomAccess, Serializable {
private static final long serialVersionUID = -4598088075242913858L;
private final Class> clazz;
private T[] elementData;
private int size;
/**
* Construct a FastList with a default size of 32.
* @param clazz the Class stored in the collection
*/
@SuppressWarnings("unchecked")
public FastList(Class> clazz) {
this.elementData = (T[]) Array.newInstance(clazz, 32);
this.clazz = clazz;
}
/**
* Construct a FastList with a specified size.
* @param clazz the Class stored in the collection
* @param capacity the initial size of the FastList
*/
@SuppressWarnings("unchecked")
public FastList(Class> clazz, int capacity) {
this.elementData = (T[]) Array.newInstance(clazz, capacity);
this.clazz = clazz;
}
/**
* Add an element to the tail of the FastList.
*
* @param element the element to add
*/
@Override
public boolean add(T element) {
if (size < elementData.length) {
elementData[size++] = element;
}
else {
// overflow-conscious code
final int oldCapacity = elementData.length;
final int newCapacity = oldCapacity << 1;
@SuppressWarnings("unchecked")
final T[] newElementData = (T[]) Array.newInstance(clazz, newCapacity);
System.arraycopy(elementData, 0, newElementData, 0, oldCapacity);
newElementData[size++] = element;
elementData = newElementData;
}
return true;
}
/**
* Get the element at the specified index.
*
* @param index the index of the element to get
* @return the element, or ArrayIndexOutOfBounds is thrown if the index is invalid
*/
@Override
public T get(int index) {
return elementData[index];
}
/**
* Remove the last element from the list. No bound check is performed, so if this
* method is called on an empty list and ArrayIndexOutOfBounds exception will be
* thrown.
*
* @return the last element of the list
*/
public T removeLast() {
T element = elementData[--size];
elementData[size] = null;
return element;
}
/**
* This remove method is most efficient when the element being removed
* is the last element. Equality is identity based, not equals() based.
* Only the first matching element is removed.
*
* @param element the element to remove
*/
@Override
public boolean remove(Object element) {
for (int index = size - 1; index >= 0; index--) {
if (element == elementData[index]) {
final int numMoved = size - index - 1;
if (numMoved > 0) {
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
}
elementData[--size] = null;
return true;
}
}
return false;
}
/**
* Clear the FastList.
*/
@Override
public void clear() {
for (int i = 0; i < size; i++) {
elementData[i] = null;
}
size = 0;
}
/**
* Get the current number of elements in the FastList.
*
* @return the number of current elements
*/
@Override
public int size() {
return size;
}
/** {@inheritDoc} */
@Override
public boolean isEmpty() {
return size == 0;
}
/** {@inheritDoc} */
@Override
public T set(int index, T element) {
T old = elementData[index];
elementData[index] = element;
return old;
}
/** {@inheritDoc} */
@Override
public T remove(int index) {
if (size == 0) {
return null;
}
final T old = elementData[index];
final int numMoved = size - index - 1;
if (numMoved > 0) {
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
}
elementData[--size] = null;
return old;
}
/** {@inheritDoc} */
@Override
public boolean contains(Object o) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public Iterator<T> iterator() {
return new Iterator<T>() {
private int index;
@Override
public boolean hasNext() {
return index < size;
}
@Override
public T next() {
if (index < size) {
return elementData[index++];
}
throw new NoSuchElementException("No more elements in FastList");
}
};
}
/** {@inheritDoc} */
@Override
public Object[] toArray()
{
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public <E> E[] toArray(E[] a)
{
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public boolean containsAll(Collection> c) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public boolean addAll(Collection extends T> c) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public boolean addAll(int index, Collection extends T> c) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public boolean removeAll(Collection> c) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public boolean retainAll(Collection> c) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public void add(int index, T element) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public int indexOf(Object o) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public int lastIndexOf(Object o) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public ListIterator<T> listIterator() {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public ListIterator<T> listIterator(int index) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public List<T> subList(int fromIndex, int toIndex) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public Object clone() {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public void forEach(Consumer super T> action) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public Spliterator<T> spliterator() {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public boolean removeIf(Predicate super T> filter) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public void replaceAll(UnaryOperator<T> operator) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
@Override
public void sort(Comparator super T> c) {
throw new UnsupportedOperationException();
}
}
參考資料
-
https://github.com/brettwooldridge/HikariCP/wiki/Down-the-Rabbit-Hole
END
