小红书二面的一些记录

今天面试小红书二面，感觉整体上考察还是比较基础。根据小红书面试官透露，在开发中使用kotlin比较多；公司有跨平台的，但还是原生比较多。这里就记录几个回答不是怎么好的问题：

1. 实现线程安全队列

首先是实现一个队列，可以自动扩容，底层为int[] 类型。对于怎么以最小的代价来保证其线程安全，这里可能我说的不是最优的，这里需要看下Java相关类的设计思想。

首先给出我的非多线程版本：

class Queue{
    private int[] arr;
    int preIndex = 0;
    int lastIndex = 0;
    public Queue(int size){
        this.arr = new int[size];
    }

    public void enqueue(int a){
        if(lastIndex == this.arr.length - 1){
            // todo 扩容
            int newSize = (lastIndex + 1) * 2 + 1;
            int[] newArr = new int[newSize];
            int[] datas = Arrays.copyOfRange(this.arr, preIndex, lastIndex);
            for (int i = 0; i < datas.length; i++) {
                newArr[i] = datas[i];
            }
            this.preIndex = 0;
            this.lastIndex = datas.length;
            this.arr = newArr;
        }
        this.arr[lastIndex] = a;
        lastIndex++;
    }

    public int dequeue(){
        if(preIndex > lastIndex) return -1;
        if(lastIndex - preIndex >= 5){ // 阈值设置为5，略微避免空间浪费
            int size = this.size();
            for (int i = 0; i < size; i++) {
                this.arr[i] = this.arr[preIndex++];
            }
            preIndex = 0;
            lastIndex = size;
        }
        return this.arr[preIndex++];
    }

    public int size(){
        return lastIndex - preIndex;
    }
}

在看SparseArray的源码的时候，发现在put操作的时候，因为底层也是数组的实现。在每次插入元素的时候都使用了System.arraycopy函数来整体移动数组元素，这里或许可以借鉴：

public int dequeue(){
    if(preIndex > lastIndex) return -1;
    if(lastIndex - preIndex >= 5){ 
        moveData(preIndex, lastIndex - 1);
    }
    return this.arr[preIndex++];
}

private synchronized void moveData(int left, int right){
    int size = right - left + 1;
    System.arraycopy(this.arr, left, this.arr, 0, size); // here
    preIndex = 0;
    lastIndex = size;
}

然后面试官要求线程安全，且以最小的代价来实现。

我们可以粗暴的在操作数组的方法定义处加入synchronized关键字，然后在arr定义处加入volatile关键字。比如：

private volatile int[] arr;
public synchronized void enqueue(int a){}

观察上面的实现，我们在扩容和出队的时候整体复制均应该是原子操作，故而这两个方法可以考虑抽离出来，而这两个方法剩下的部分应该是可以优化的地方。那么就来尝试写一下：

暂时还没有好的思路，先占个坑，之后填。

2. Android中的序列化方式

其实是序列化，当我说道Serializable的时候，当时竟然不会读这个单词了，尴尬的很。那么为什么需要使用Parcelable来替代Serializable？当时回答是出于性能考虑，我觉得没有这么简单。需要再整理下。

Serializable是Java提供的序列化接口，使用起来简单但是开销大，序列化和反序列化的过程需要大量的I/O操作。
Parcelable是Android提供的序列化方式，效率较高，但是使用起来稍微麻烦。这是Android推荐的序列化方式，且主要作用在内存上。

3. 提供了哪些类似于SparseArray的替代类？

注意到SparseArray的全类限定名为android.util.SparseArray。那么可以尝试在官网看看，地址。

• ArrayMap
• ArraySet
• LongSparseArray
• SparseBooleanArray
• SparseIntArray
• SparseLongArray

其实之前的博客：SparseArray中介绍过，这里不再介绍，等有空了看下这个类的源码看看。

3.1 SparseArray

在之前的博客中提到过SparseArray的特性：

• 对于SparseArray，比HashMap更省内存，在某些条件下性能更好，主要是因为它避免了对key的自动装箱（int转为Integer类型等）；
• SparseArray内部通过两个数组来进行数据存储的，一个存储key，另外一个存储value，为了优化性能，它内部对数据还采取了压缩的方式来表示稀疏数组的数据，大大减少了存储空间，节约内存；
• 同时，还实现了SparseIntArray、SparseLongArray、SparseBooleanArray等。
• SparseArray性能比较好，查找算法是二分法，提高了查找的效率。但是其添加、查找、删除数据都需要先进行一次二分查找，在数据量大的情况下性能并不明显。

那么之类结合源码来看看：

public class SparseArray<E> implements Cloneable {
	private int[] mKeys;  // 所以只能存储int类型的key，且没有装箱，从而避免了拆装箱的成本。
	private Object[] mValues;
	private int mSize;
	// 查找
	public E get(int key) {
        return get(key, null);
    }
    public E get(int key, E valueIfKeyNotFound) {
    	// 二分查找，传入数组、大小、key
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i < 0 || mValues[i] == DELETED) {
            return valueIfKeyNotFound;
        } else {
            return (E) mValues[i];
        }
    }
    // 删除
	public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
    }
    // 插入
	public void put(int key, E value) {
		// 查找是否存在，存在返回下标位置
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            mValues[i] = value;  // 存在直接替换新值
        } else {
            i = ~i;  // 二分查找的下标

            if (i < mSize && mValues[i] == DELETED) { // 这个位置没有数据，直接插入
                mKeys[i] = key;
                mValues[i] = value;
                return;
            }
			// 存在垃圾，需要垃圾回收
            if (mGarbage && mSize >= mKeys.length) {
                gc(); // 有效数据移动到数组首部

                // Search again because indices may have changed.
                i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
            }
			
			// 将元素插入到指定位置i，如果容量不够会自动扩容（2倍扩容）
			// 内部使用System.arraycopy来实现数组的拷贝
            mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
            mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
            mSize++;
        }
    }
    
}

至于压缩存储，这里暂时没有看见。其余的特性倒是显而易见。

4. Handler消息机制中，消息是可以设置优先级的

这一点需要明天去了继续仔细看看源码才知道。

在上一篇Message对象的when?Hanlder是如何将一个延迟消息添加到消息队列的？中，我们知道了插入到消息队列的消息是按照消息的when字段来进行排序的队列的。且这个when字段是会加上系统开机到现在的时间，即：

sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);

为了提高消息在消息队列的优先级，那么我们可以让具有高优先级的消息对象每次插入在消息队列的队首即可。也就是说，需要让when字段足够的小。

在Handler中提供了两种方法，分别为：

handler.sendMessageAtFrontOfQueue(new Message());
handler.postAtFrontOfQueue(new Runnable() {
    @Override
    public void run() {
        
    }
});

首先来看下sendMessageAtFrontOfQueue这个方法：

public final boolean sendMessageAtFrontOfQueue(@NonNull Message msg) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, 0);  // 直接设置为0
}

上面的源码可以看出其特殊性，直接将when设置为0，没有加入开机到现在的时间，所以确保一定加入到消息队列首部。所以通过这个方法可以发送一个具有较高优先级的方法。

类似的，postAtFrontOfQueue这个方法最终也会调用上面的方法。

---

Thanks

• https://blog.csdn.net/dongrimaomaoyu/article/details/115967588