package rtc;
// 实现消息监听
public interface RtcEvent {
    void handleMessage(RtcMessage msg);
}

package rtc;
// 统一化消息体
public class RtcMessage {
    public String key; // 消息的Key
    public int value; // 消息的内容
    public long time; // 消息创建的时间戳

    public RtcMessage() {
        this.time = System.currentTimeMillis();
    }
}

package rtc;
// 模拟Rtc功能SDK的实现
public class RtcClient {

    private boolean shutdown = true;

    public RtcClient(String uuid) {
        shutdown = false;
    }

    // 监听发送来的心跳和消息，用线程来模拟
    public void onListening(RtcEvent e) {

        // 模拟定时接收心跳的线程
        Thread t = new Thread(() -> {
            for (int i = 0; !shutdown ; i++) {
                RtcMessage heartbeat = new RtcMessage();
                heartbeat.key = null;
                e.handleMessage(heartbeat);
                System.out.println("心跳："+ i);

                // 1、模拟中间接收到消息
                if (i == 10) {
                    // 执行命令
                    RtcMessage cmdMsg = new RtcMessage();
                    cmdMsg.key = "MOVE";
                    cmdMsg.value = 1000;
                    e.handleMessage(cmdMsg);
                }

                // 2、模拟掉线
                if (i == 15){
                    try {
                        Thread.sleep(2000);
                        break;
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        });
        t.start();

    }

    // 模拟发送出去心跳
    public void send(RtcMessage msg) {
        System.out.println("send heartbeat: " + msg.time);
        //        e.handleMessage();
    }

    // 停止
    public void close() {
        // 让线程停止
        this.shutdown = true;
    }
}

import rtc.RtcClient;
import rtc.RtcMessage;

public class Car {

    // SDK提供的 rtc 客户端
    private static RtcClient rtcClient;
    // 判断小车是否已经开启
    public static volatile boolean isOn;
    // 心跳线程
    private static Thread heartbeatThread;
    // 连接 的 rtc room 的 id
    private String uuid;
    // 上一次心跳时间
    private long lastHeartbeatTime = -1;
    // 死亡沟壑时间，如果超过2000毫秒未接受到心跳，则说明挂了，需要重启client
    public static final int DEAD_GAP_TIME = 2000;

    public Car(String uuid){
        this.uuid = uuid;
        rtcClient = new RtcClient(uuid);

        // 定时发送心跳的线程
        heartbeatThread = new Thread(() -> {
            for(;;){
                // 探活，是否可以按时接收到心跳，如果不可以，则说明client可能断开连接了，需要重新连接
                checkAndReset();
                System.out.println("last heartbeat: " + this.lastHeartbeatTime);
                rtcClient.send(new RtcMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 开启心跳探活线程
        heartbeatThread.start();
    }

    /**
     * 重置 rtc 连接
     */
    private synchronized void checkAndReset() {
        if (lastHeartbeatTime == -1){
            // 刚初始化，跳过
            return;
        }
        // 如果超过2000毫秒未接受到心跳，则说明挂了，需要重启client
        if (System.currentTimeMillis() - lastHeartbeatTime > DEAD_GAP_TIME){
            if(rtcClient != null){
                rtcClient.close();
            }
            // 重新建立连接
            rtcClient = new RtcClient(this.uuid);
            startUp();// 重新监听
            System.out.println("reset: "+ rtcClient);
        }
    }

    /**
     * 开启小车
     */
    public synchronized void startUp(){

        // 开始监听 uuid room 的 rtc的消息
        rtcClient.onListening(receiveMsg -> {

            // 判断如果是心跳，则更新上一次探活时间
            if (receiveMsg.key == null){
                lastHeartbeatTime = receiveMsg.time;
            }else {
                // 执行rtc消息传来的命令，让小车进行相应的动作
                executeCommand(receiveMsg.key, receiveMsg.value);
                System.out.println("[ Cmd: " + receiveMsg.key + ", val: " + receiveMsg.value + " ]");

            }
        });
    }

    /**
     * 执行命令
     * @param cmd 对应的指令
     * @param v 值
     */
    private void executeCommand(String cmd, int v){
        switch (cmd) {
            case "MOVE":
                move(v);
                break;
            case "SPIN":
                spin(v);
                break;
        }
    }


    /**
     * 移动距离
     * @param distance 距离
     */
    private void move(int distance){
        System.out.println("move " + distance);
    }

    /**
     * 旋转角度
     * @param angle 角度
     */
    private void spin(int angle){
        System.out.println("spin " + angle);
    }

}

public class DemoMain {

    public static void main(String[] args) throws InterruptedException {
        Car c = new Car("10086");
        c.startUp();
        Thread.sleep(10000);
    }
}

package rtc;

public class RtcMessage implements Comparable<RtcMessage> {
    public String key;
    public int value;
    public long time;
    public long seq;

    public RtcMessage() {
        this.time = System.currentTimeMillis();
    }


    @Override // 实现比较，为了让消息自排序，后面会讲为什么要实现这个方法
    public int compareTo(RtcMessage o) {
        if (this.seq > o.seq) {
            return -1;
        }
        return 1;
    }
}

package rtc;

import java.util.ArrayList;
import java.util.List;

public class RtcClient {

    // 使用标志位来控制线程的停止
    private boolean shutdown = true;

    public RtcClient(String uuid) {
        shutdown = false;
    }

    // 监听发送来的心跳和消息，用线程来模拟
    public void onListening(RtcEvent e) {

        // 定时发送心跳的线程
        Thread t = new Thread(() -> {
            for (int i = 0; !shutdown ; i++) {
                RtcMessage heartbeat = new RtcMessage();
                heartbeat.key = null;
                e.handleMessage(heartbeat);
                System.out.println("心跳："+ i);

                // 模拟中间接收到消息
                if (i == 10) {

                    // 正确顺序，0-MOVE、1-SPIN、2-MOVE、3-SPIN、4-MOVE
                    // 先生成顺序消息
                    List<RtcMessage> msgList = new ArrayList<>(); // 使用list装
                    for(int j = 0; j < 5; j++){
                        RtcMessage cmdMsg = new RtcMessage();
                        if ((j & 1) == 0){
                            // 执行命令
                            cmdMsg.key = "MOVE";
                            cmdMsg.value = 1000;
                        }else {
                            // 执行命令
                            cmdMsg.key = "SPIN";
                            cmdMsg.value = 90;
                        }
                        cmdMsg.seq = j;
                        msgList.add(cmdMsg);
                    }
                    // 然后开启多线程发送指令
                    msgList.forEach(msg -> {
                        new Thread(() -> {
                            e.handleMessage(msg);
                        }).start();
                    });


                }

                // 模拟掉线
                if (i == 15){
                    try {
                        Thread.sleep(2000);
                        break;
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        });
        t.start();

    }

    // 模拟发送出去心跳
    public void send(RtcMessage msg) {
        System.out.println("send heartbeat: " + msg.time);
        //        e.handleMessage();
    }

    // 停止
    public void close() {
        // 让线程停止
        this.shutdown = true;
    }
}

import rtc.RtcClient;
import rtc.RtcMessage;

import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReentrantLock;

public class Car {

    // SDK提供的 rtc 客户端
    private static RtcClient rtcClient;
    // 判断小车是否已经开启
    public static volatile boolean isOn;
    // 心跳线程
    private static Thread heartbeatThread;
    // 连接 的 rtc room 的 id
    private String uuid;
    // 上一次心跳时间
    private long lastHeartbeatTime = -1;
    // 死亡沟壑时间，如果超过2000毫秒未接受到心跳，则说明挂了，需要重启client
    private static final int DEAD_GAP_TIME = 2000;
    // 记录上一次消费的命令Seq
    private static final AtomicLong lastSeq = new AtomicLong();
    // 顺序队列
    private static final PriorityBlockingQueue<RtcMessage> waitingQueue = new PriorityBlockingQueue<>();
    // 锁
    private static final ReentrantLock lock = new ReentrantLock();

    public Car(String uuid) {
        this.uuid = uuid;
        rtcClient = new RtcClient(uuid);

        // 定时发送心跳的线程
        heartbeatThread = new Thread(() -> {
            for (; ; ) {
                // 探活，是否可以按时接收到心跳，如果不可以，则说明client可能断开连接了，需要重新连接
                checkAndReset();
                System.out.println("last heartbeat: " + this.lastHeartbeatTime);
                rtcClient.send(new RtcMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 开启心跳探活线程
        heartbeatThread.start();
        initMsgWaitingQueue();
    }

    /**
     * 初始化命令消费等待队列，开启线程，轮询等待队列，做到有顺序消费（执行命令）
     */
    private void initMsgWaitingQueue() {
        // 初始化首次消费命令顺序为0，以后每消费一次，序列号都+1，这个在tcp中可以作为ACK
        new Thread(() -> {
            for (; ; ) {
                lock.lock();
                System.out.println("wait for command...");
                if (waitingQueue.size() == 0) {
                    // 还没有消息
//                    System.out.println("null message.");
                } else {
                    RtcMessage receiveMsg = waitingQueue.peek();

                    // 如果本次有消息
                    // 如果这次的消息序列号不等于上次+1，即 seq != lastSeq + 1，则还需要再把它入队列，再等等
                    if (receiveMsg.seq != lastSeq.get()) {
                        // 既然不相等，那就需要再减回去
                        System.out.printf("receiveMsg seq: %d, last seq: %d\n", receiveMsg.seq, lastSeq.get());
                        System.out.println("not sequence message, continue wait...");
                    } else {
                        // 若 seq = lastSeq + 1，则直接执行命令，进行消费
                        executeCommand(receiveMsg.key, receiveMsg.value);
                        lastSeq.addAndGet(1); // 标记上次消费的位置
                        System.out.println("[ Seq: " + receiveMsg.seq + ", Cmd: " + receiveMsg.key + ", val: " + receiveMsg.value + " ]");
                        waitingQueue.poll();
                        continue;
                    }
                }
                lock.unlock();

                // 等一下消息吧
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }).start();
    }

    /**
     * 重置 rtc 连接
     */
    private synchronized void checkAndReset() {
        if (lastHeartbeatTime == -1){
            // 刚初始化，跳过
            return;
        }
        // 如果超过2000毫秒未接受到心跳，则说明挂了，需要重启client
        if (System.currentTimeMillis() - lastHeartbeatTime > DEAD_GAP_TIME) {
            if (rtcClient != null) {
                rtcClient.close();
            }
            // 重新建立连接
            rtcClient = new RtcClient(this.uuid);
            startUp();// 重新监听
            System.out.println("reset: " + rtcClient);
        }
    }

    /**
     * 开启小车
     */
    public synchronized void startUp() {

        // 开始监听 uuid room 的 rtc的消息
        rtcClient.onListening(receiveMsg -> {

            // 判断如果是心跳，则更新上一次探活时间
            if (receiveMsg.key == null) {
                lastHeartbeatTime = receiveMsg.time;
            } else {
                // 执行rtc消息传来的命令，让小车进行相应的动作
//                executeCommand(receiveMsg.key, receiveMsg.value);
//                System.out.println("[ Seq: " + receiveMsg.seq + ", Cmd: " + receiveMsg.key + ", val: " + receiveMsg.value + " ]");
                addWaitingQueue(receiveMsg); // 添加等待队列，来代替直接消费，这里使用优先队列保证顺序
            }
        });
    }

    /**
     * @param receiveMsg 接收到的消息
     */
    private void addWaitingQueue(RtcMessage receiveMsg) {
        // 加个锁吧~
        lock.lock();
        waitingQueue.offer(receiveMsg);
        lock.unlock();
    }


    /**
     * 执行命令
     *
     * @param cmd 对应的指令
     * @param v   值
     */
    private void executeCommand(String cmd, int v) {
        switch (cmd) {
            case "MOVE":
                move(v);
                break;
            case "SPIN":
                spin(v);
                break;
        }
    }


    /**
     * 移动距离
     *
     * @param distance 距离
     */
    private void move(int distance) {
        System.out.println("move " + distance);
    }

    /**
     * 旋转角度
     *
     * @param angle 角度
     */
    private void spin(int angle) {
        System.out.println("spin " + angle);
    }

    public void close() {
        synchronized (waitingQueue) {
            waitingQueue.forEach(c -> System.out.print("*****************" + c.seq + ", "));
            System.out.println();
        }

    }
}

上面通过对 小车（Car） 的改造，将【收到命令立即执行命令】改为【收到命令后先放入优先队列】，然后【对命令进行有序执行】，顺利的解决了命令乱序的问题，真的是 Awesome ~

// Car.class
    /**
     * 开启小车
     */
    public synchronized void startUp() {

        // 开始监听 uuid room 的 rtc的消息
        rtcClient.onListening(receiveMsg -> {
            // 判断如果是心跳，则更新上一次探活时间
            if (receiveMsg.key == null) {
                lastHeartbeatTime = receiveMsg.time;
            } else {
                // 执行rtc消息传来的命令，让小车进行相应的动作

                if(new Random().nextBoolean()){
                    // 模拟随机丢包
                    System.out.println("消息丢失啦【" + receiveMsg.seq + ", "+receiveMsg.key + ": " + receiveMsg.value + "】");
                    return;
                }
//                executeCommand(receiveMsg.key, receiveMsg.value);
//                System.out.println("[ Seq: " + receiveMsg.seq + ", Cmd: " + receiveMsg.key + ", val: " + receiveMsg.value + " ]");
                addWaitingQueue(receiveMsg); // 添加等待队列，来代替直接消费，这里使用优先队列保证顺序
            }
        });
    }

// RtcClient.class
    // 这里可以设置多倍发包的倍数
    private static final int MULTIPLE_MESSAGE_SEND_TIMES = 3;
// 监听发送来的心跳和消息，用线程来模拟
    public void onListening(RtcEvent e) {

        // 定时发送心跳的线程
        Thread t = new Thread(() -> {
            for (int i = 0; !shutdown ; i++) {
                RtcMessage heartbeat = new RtcMessage();
                heartbeat.key = null;
                e.handleMessage(heartbeat);
                System.out.println("心跳："+ i);

                // 模拟中间接收到消息
                if (i == 10) {

                    // 正确顺序，0-MOVE、1-SPIN、2-MOVE、3-SPIN、4-MOVE
                    // 先生成顺序消息
                    List<RtcMessage> msgList = new ArrayList<>(); // 使用list装
                    for(int j = 0; j < 5; j++){
                        RtcMessage cmdMsg = new RtcMessage();
                        if ((j & 1) == 0){
                            // 执行命令
                            cmdMsg.key = "MOVE";
                            cmdMsg.value = 1000;
                        }else {
                            // 执行命令
                            cmdMsg.key = "SPIN";
                            cmdMsg.value = 90;
                        }
                        cmdMsg.seq = j;
                        msgList.add(cmdMsg);
                    }
                    // 然后开启多线程发送指令
                    msgList.forEach(msg -> {
                        new Thread(() -> {
                            // 多倍发包
                            for (int j = 0; j < MULTIPLE_MESSAGE_SEND_TIMES; j++) {
                                e.handleMessage(msg);
                            }
                        }).start();
                    });


                }

                // 模拟掉线
                if (i == 15){
                    try {
                        Thread.sleep(2000);
                        break;
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        });
        t.start();

    }

Car.class
    /**
     * 初始化命令消费等待队列，开启线程，轮询等待队列，做到有顺序消费（执行命令）
     */
    private void initMsgWaitingQueue() {
        // 初始化首次消费命令顺序为0，以后每消费一次，序列号都+1，这个在tcp中可以作为ACK
        new Thread(() -> {
            for (; ; ) {
                lock.lock();
                System.out.println("wait for command...");
                if (waitingQueue.size() == 0) {
                    // 还没有消息
//                    System.out.println("null message.");
                } else {
                    RtcMessage receiveMsg = waitingQueue.peek();
                    // 如果队首的Command的Seq小于当前执行的lastSeq，那么说明这条命令已经被执行了，所以丢掉
                    if (receiveMsg.seq < lastSeq.get()){
                        waitingQueue.poll(); // 丢掉
                        continue; // 直接进行下一轮
                    }

                    // 如果本次有消息
                    // 如果这次的消息序列号不等于上次+1，即 seq != lastSeq + 1，则还需要再把它入队列，再等等
                    if (receiveMsg.seq != lastSeq.get()) {
                        // 既然不相等，那就需要再减回去
                        System.out.printf("receiveMsg seq: %d, last seq: %d\n", receiveMsg.seq, lastSeq.get());
                        System.out.println("not sequence message, continue wait...");
                    } else {
                        // 若 seq = lastSeq + 1，则直接执行命令，进行消费
                        executeCommand(receiveMsg.key, receiveMsg.value);
                        lastSeq.addAndGet(1); // 标记上次消费的位置
                        System.out.println("[ Seq: " + receiveMsg.seq + ", Cmd: " + receiveMsg.key + ", val: " + receiveMsg.value + " ]");
                        waitingQueue.poll();
                        continue;
                    }
                }
                lock.unlock();

                // 等一下消息吧
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


//                    try {
//                        RtcMessage receiveMsg = waitingQueue.poll(1, TimeUnit.SECONDS);
//                        if (receiveMsg == null) {
//                            System.out.println("null message.");
//                            continue;
//                        }
//                        waitingQueue.forEach(c -> System.out.println(c.seq));
//                        // 如果这次的消息序列号不等于上次+1，即 seq != lastSeq + 1，则还需要再把它入队列，再等等
//                        if (receiveMsg.seq != lastSeq.get() + 1) {
//                            addWaitingQueue(receiveMsg); // 再次入队
//                            Thread.sleep(1000); // 再等待一秒吧
//                            continue;
//                        }
//                        // 若 seq = lastSeq + 1，则直接执行命令
//                        executeCommand(receiveMsg.key, receiveMsg.value);
//                        lastSeq.addAndGet(1); // 标记上次消费的位置
//                        System.out.println("[ Seq: " + receiveMsg.seq + ", Cmd: " + receiveMsg.key + ", val: " + receiveMsg.value + " ]");
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
            }

        }).start();
    }

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 确保新元素可添加的条件为容量大于等于size+1
    elementData[size++] = e;//在数组尾部添加元素，顺便size+1
    return true;
}

public void add(int index, E element) {
        rangeCheckForAdd(index);//数组越界Check，条件：index > size  index < 0

        ensureCapacityInternal(size + 1);  //这句为了确保要插入数据容量至少大于size+1，内部实现中如果minCapacity - elementData.length > 0会调用grow方法扩容。
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);//arraycopy是一个native方法，作用是将要插入位置后的所有元素后移一位，在index处预留出空间以供新元素插入
        elementData[index] = element;//把预插入元素放置到index位置
        size++;//list大小增加
}

    private void grow(int minCapacity) {//传参为最小需要扩容的大小
        // overflow-conscious code
        int oldCapacity = elementData.length;//原有容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量为原容量的1.5倍
        if (newCapacity - minCapacity < 0)//如果新容量（1.5倍）小于最小需要容量（原因：int取值范围越界）
            newCapacity = minCapacity;//赋值为最小所需容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)//如果新容量大于int最大值-8
            newCapacity = hugeCapacity(minCapacity);//则利用hugeCapacity进行计算复制大小（后面有写）
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//分配好新空间，可以对旧数组进行扩容
    }


    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow 溢出
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE ://最小分配大小大于Integer_Max-8则复制为int最大值
            MAX_ARRAY_SIZE;
    }

//此外，如ensureCapacity等方法，内部都是调用grow来进行扩容，没什么其他内容，这里就不谈了

public E remove(int index) {
    rangeCheck(index);//检查index越界

    modCount++;//标记修改次数，类似版本号
    E oldValue = elementData(index);//取出index位置的元素

    int numMoved = size - index - 1;//需要移动元素的个数，也就是如果从index位置删除元素，那么后续所有其他元素需要前移一位来补空缺
    if (numMoved > 0)//如果移动的元素不是最后一个元素，则都需要前移后面所有元素，由此可见，如果移除index=0的元素的效率最差，需要数组整体前移
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);//移动操作
    elementData[--size] = null; // clear to let GC do its work，将最后一个元素位置置为null，原注释解释方便GC回收垃圾

    return oldValue;//返回删除的元素
}

public boolean remove(Object o) {
        if (o == null) {//如果要移除元素为null
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {遍历查找数值=null的元素
                    fastRemove(index);//实际就是封装了之前移除过程
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {//使用equals来进行比较，如果相等，则移除
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

//此方法基本上就是对于之前移除过程进行封装，可参考public E remove(int index)中的移除注释
private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

public Iterator<E> iterator() {//默认调用此方法
            return listIterator();//其中会调用listIterator(0)，也就是从0位置开始迭代
}        

public ListIterator<E> listIterator(final int index) {
            checkForComodification();//检测修改版本号，for concurrent
            rangeCheckForAdd(index);//检测越界
            final int offset = this.offset;

            return new ListIterator<E>() {
                int cursor = index;//内部维护索引，默认为0开始
                int lastRet = -1;//记录上一次返回的索引，初始化为-1
                int expectedModCount = ArrayList.this.modCount;

                public boolean hasNext() {//是否有下一个元素
//这里使用sublist，实际上内部有属性指向parent(当前list)，可理解为就是当前list
                    return cursor != SubList.this.size;//判断游标是否到达list的size

                }

                @SuppressWarnings("unchecked")
                public E next() {
                    checkForComodification();//检查修改次数版本号
                    int i = cursor;
                    if (i >= SubList.this.size)//如果越界，抛出无元素异常
                        throw new NoSuchElementException();
                    Object[] elementData = ArrayList.this.elementData;//创建对list的引用
                    if (offset + i >= elementData.length)//越界
                        throw new ConcurrentModificationException();
                    cursor = i + 1;//此时游标自动后移，为了迭代继续进行
                    return (E) elementData[offset + (lastRet = i)];//返回通过游标取出的元素，更新lastRet为当前返回的索引
                }

                public boolean hasPrevious() {//如果游标不等于0，则有前置元素
                    return cursor != 0;
                }

                @SuppressWarnings("unchecked")
                public E previous() {//返回前置元素，与next方法大同小异
                    checkForComodification();
                    int i = cursor - 1;
                    if (i < 0)
                        throw new NoSuchElementException();
                    Object[] elementData = ArrayList.this.elementData;
                    if (offset + i >= elementData.length)
                        throw new ConcurrentModificationException();
                    cursor = i;
                    return (E) elementData[offset + (lastRet = i)];
                }

                @SuppressWarnings("unchecked")//支持lambda表达式特性的方法
                public void forEachRemaining(Consumer<? super E> consumer) {
                    Objects.requireNonNull(consumer);
                    final int size = SubList.this.size;
                    int i = cursor;
                    if (i >= size) {
                        return;
                    }
                    final Object[] elementData = ArrayList.this.elementData;
                    if (offset + i >= elementData.length) {
                        throw new ConcurrentModificationException();
                    }
                    while (i != size && modCount == expectedModCount) {
                        consumer.accept((E) elementData[offset + (i++)]);
                    }
                    // update once at end of iteration to reduce heap write traffic
                    lastRet = cursor = i;
                    checkForComodification();
                }

                public int nextIndex() {//返回游标下一次访问的元素位置
                    return cursor;
                }

                public int previousIndex() {//返回上一个访问的位置
                    return cursor - 1;
                }

                public void remove() {//移除元素
                    if (lastRet < 0)
                        throw new IllegalStateException();
                    checkForComodification();//同上

                    try {
                        SubList.this.remove(lastRet);//内部调用此list的remove方法去移除刚访问过的元素
                        cursor = lastRet;//移除后，内部游标则跳到上一次访问元素位置
                        lastRet = -1;//上一次访问元素因为被删除，所以lastret又置为-1
                        expectedModCount = ArrayList.this.modCount;
                    } catch (IndexOutOfBoundsException ex) {
                        throw new ConcurrentModificationException();
                    }
                }

                public void set(E e) {
                    if (lastRet < 0)
                        throw new IllegalStateException();
                    checkForComodification();//修改版本检测

                    try {
                        ArrayList.this.set(offset + lastRet, e);//调用set方法设置当前元素为新值
                    } catch (IndexOutOfBoundsException ex) {
                        throw new ConcurrentModificationException();
                    }
                }

                public void add(E e) {
                    checkForComodification();

                    try {
                        int i = cursor;
                        SubList.this.add(i, e);//在当前游标位置添加元素
                        cursor = i + 1;//游标后移一位
                        lastRet = -1;
                        expectedModCount = ArrayList.this.modCount;//设置期望的修改版本号，此处运用了类似CAS的控制机制，在许多方法调用前会有checkForComodification()方法来进行修改版本号检测
                    } catch (IndexOutOfBoundsException ex) {
                        throw new ConcurrentModificationException();
                    }
                }


                final void checkForComodification() {//修改版本号检测
                    if (expectedModCount != ArrayList.this.modCount)
//这里使用了期望修改版本号与当前修改版本号对比，来判断是否期间有其他线程修改了这个值，利用CAS机制，以支持并发操作；如果不一致抛出并发修改异常
                        throw new ConcurrentModificationException();
                }
            };
        }

 public E get(int index) {
    rangeCheck(index);//检查越界

    return elementData(index);//直接返回元素
}


public E set(int index, E element) {
    rangeCheck(index);//检查越界

    E oldValue = elementData(index);//记录index位置的旧元素
    elementData[index] = element;//将index位置设置为新元素
    return oldValue;//返回旧元素
}

keytool -importkeystore -srckeystore G:\APK\android.jks -destkeystore G:\APK\android.jks -deststoretype pkcs12

pip install beautifulsoup4

import bs4
print bs4
# 运行该文件，如果能够正常输出则安装成功。

var VideoListJson = \[\['优酷', \['\\u7B2C01\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/12846619\_6ba8b4e916d2137e040897949fd54e3b.mp4$flv', '\\u7B2C02\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/12846619\_26f1a781b59cddedda710b379d519a45.mp4$flv', '\\u7B2C03\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/12846619\_14a61ab058bb8baa34fe10afab0f6d9d.mp4$flv', '\\u7B2C04\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/25330672\_fe7f827fc305a64ffad425635f0a85dc.mp4$flv', '\\u7B2C05\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/25330672\_45fdd31b21780f648f99169fef713bf5.mp4$flv', '\\u7B2C06\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/25330672\_d2b1aeb2de9fd044cf797f163f726073.mp4$flv', '\\u7B2C07\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/25330672\_53044ba7dd316163808c4c54f8b62bce.mp4$flv', '\\u7B2C08\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/25330672\_c69961fd5359c8827d0695d89e64a1f3.mp4$flv', '\\u7B2C09\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/25330672\_eccb48c876b6b7f0b26e58c08b1d7d6e.mp4$flv', '\\u7B2C10\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/607272\_f961e61c07e48e0bcb834e5577837990.mp4$flv', '\\u7B2C11\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/607272\_7336ab3e3ae49ce9eae3af5d33d64572.mp4$flv', '\\u7B2C12\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/607272\_3b11ef60d8ec1cd02fa2f2f2f8e08b95.mp4$flv', '\\u7B2C13\\u96C6$https://gss3.baidu.com/6LZ0ej3k1Qd3ote6lo7D0j9wehsv/tieba-smallvideo/607272\_4fcf619108604f6d9e01687e5c69a2bd.mp4$flv'\]\], \['优酷', \['\\u7B2C01\\u96C6$https://ck-qq.com/v/isgc9ZhZ$zw', '\\u7B2C02\\u96C6$https://ck-qq.com/v/OmVVtwys$zw', '\\u7B2C03\\u96C6$https://ck-qq.com/v/5ufXonER$zw', '\\u7B2C04\\u96C6$https://ck-qq.com/v/a4csbpC5$zw', '\\u7B2C05\\u96C6$https://ck-qq.com/v/3tuLdesn$zw', '\\u7B2C06\\u96C6$https://ck-qq.com/v/GvY6JTTf$zw', '\\u7B2C07\\u96C6$https://ck-qq.com/v/JsTQI54S$zw', '\\u7B2C08\\u96C6$https://ck-qq.com/v/D8eKu51h$zw', '\\u7B2C09\\u96C6$https://ck-qq.com/v/ngr3oW92$zw', '\\u7B2C10\\u96C6$https://ck-qq.com/v/mW79A1RH$zw', '\\u7B2C11\\u96C6$https://ck-qq.com/v/OCzFYdfx$zw', '\\u7B2C12\\u96C6$https://ck-qq.com/v/vyfKm4Hv$zw', '\\u7B2C13\\u96C6$https://ck-qq.com/v/xPhMxCiV$zw'\]\]\],  
urlinfo = 'http://' + document.domain + '/player/7542-'

video_urls = list(filter(lambda s: s[:4] == 'http', js_text.split(r'$')))
# 其中js_text为上面的js文件内容

Server = https://mirrors.tuna.tsinghua.edu.cn/archlinux/$repo/os/$arch
Server = http://mirrors.aliyun.com/archlinux/$repo/os/$arch
Server = http://mirrors.163.com/archlinux/$repo/os/$arch

$ pacstrap /mnt base [base-devel] # 后面的包可缺省,最好一起下上

127.0.0.1 localhost   
::1 localhost   
127.0.1.1 myhostname.localdomain myhostname 

内容如下：

#!/bin/bash  
#chkconfig:2345 20 90  
#description:zookeeper  
#processname:zookeeper  
export JAVA_HOME=/usr/java/default
case $1 in  
        start) su - zookeeper -c '/usr/local/zookeeper-3.4.5/bin/zkServer.sh start';;  
        stop) su - zookeeper -c '/usr/local/zookeeper-3.4.5/bin/zkServer.sh stop';;  
        status) su - zookeeper -c '/usr/local/zookeeper-3.4.5/bin/zkServer.sh status';;  
        restart) su - zookeeper -c '/usr/local/zookeeper-3.4.5/bin/zkServer.sh restart';;  
        *) echo "require startstopstatusrestart" ;;  
esac