当Android应用程序的UI线程被阻塞太久时，会触发一个“应用程序没有响应”(ANR)错误。如果app在前台，系统会向用户显示一个对话框，如图1所示。ANR对话框为用户提供了强制退出应用程序的机会。 https://developer.android.com/topic/performance/vitals/anr

出现ANR的一般有以下几种类型：搜索ANR in 可以查看抛出ANR日志线程

1: KeyDispatchTimeout

• input事件在5S内没有处理完成发生了ANR。
• logcat日志关键字：Reason: Input dispatching timed out (Waiting because the focused window has not finished processing the input events that were previously delivered to it.)

2: BroadcastTimeout

• 前台Broadcast：onReceiver在10S内没有处理完成发生ANR。
• 后台Broadcast：onReceiver在60s内没有处理完成发生ANR。
• logcat日志关键字：Reason: Broadcast of Intent

3: ServiceTimeout

• 前台Service：onCreate，onStart，onBind等生命周期在20s内没有处理完成发生ANR。
• 后台Service：onCreate，onStart，onBind等生命周期在200s内没有处理完成发生ANR
• logcat日志关键字：Reason: Executing service

4: ContentProviderTimeout

• ContentProvider 在10S内没有处理完成发生ANR。
• logcat日志关键字：Reason: timeout publishing content providers

诊断ANR

• CPU密集，导致主线程没法抢占cpu时间片,要注意cpu占用高的进程
• 高IO，如不当访问数据库导致数据库负载过重时(log中cpu的使用iowait占比高)
• 低内存（low memory），如内存不足导致block在创建bitmap上
• 死锁引发ANR,非主线程持有主线程需要的锁对象,导致主线程等待超时,通常log中会有以下字段 Blocked | - locked | waiting to lock | held by thread,这个时候cpu多数是空闲，使用占比很低
• 当前应用进程进行进程间通信请求其他进程，其他进程的操作长时间没有反馈,例如操作硬件Camera
• Service binder数量达到上限
• 在system_server中触发WatchDog ANR

当遇到ANR时，Android会存储跟踪信息。 在较旧的OS版本上，设备上只有一个/data/anr/traces.txt文件。 在较新的OS发行版中，存在多个/ data / anr / anr_ *文件。可以通过adb 获取:

adb root  
adb shell ls /data/anr  
adb pull /data/anr/<filename>  

traces日志参数介绍

AsyncTask #2" prio=5 tid=18 Runnable  
  | group="main" sCount=0 dsCount=0 obj=0x12c333a0 self=0x94c87100
  | sysTid=25287 nice=10 cgrp=default sched=0/0 handle=0x94b80920
  | state=R schedstat=( 0 0 0 ) utm=757 stm=0 core=3 HZ=100
  | stack=0x94a7e000-0x94a80000 stackSize=1038KB
  | held mutexes= "mutator lock"(shared held)
  at com.android.developer.anrsample.BubbleSort.sort(BubbleSort.java:8)
  at com.android.developer.anrsample.MainActivity$LockTask.doInBackground(MainActivity.java:147)
  - locked <0x083105ee> (a java.lang.Boolean)
  at com.android.developer.anrsample.MainActivity$LockTask.doInBackground(MainActivity.java:135)
  at android.os.AsyncTask$2.call(AsyncTask.java:305)
  at java.util.concurrent.FutureTask.run(FutureTask.java:237)
  at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:243)
  at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1133)
  at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:607)
  at java.lang.Thread.run(Thread.java:761)

• main：main标识是主线程，如果是线程，那么命名成“Thread-X”的格式,x表示线程id,逐步递增。
• prio：线程优先级,默认是5
• tid：tid不是线程的id，是线程唯一标识ID
• group：是线程组名称
• sCount：该线程被挂起的次数
• dsCount：是线程被调试器挂起的次数
• obj：对象地址
• self：该线程Native的地址
• sysTid：是线程号(主线程的线程号和进程号相同)
• nice：是线程的调度优先级
• sched：分别标志了线程的调度策略和优先级
• cgrp：调度归属组
• handle：线程处理函数的地址。
• state：是调度状态
• schedstat：从 /proc/[pid]/task/[tid]/schedstat读出，三个值分别表示线程在cpu上执行的时间、线程的等待时间和线程执行的时间片长度，不支持这项信息的三个值都是0；
• utm：是线程用户态下使用的时间值(单位是jiffies）
• stm：是内核态下的调度时间值
• core：是最后执行这个线程的cpu核的序号。

线程状态

ANR发生之后log中记录的关键字段

• am_anr： 描述了anr发生时的事件，原因，进程。如果是自己的代码导致的，这里会输出你代码具体的调用类
• ANR in：mainlog 或 Syslog ，描述anr发生的应用模块
• Reason:原因
• Blocked | - locked | waiting to lock | held by thread 发生在死锁的情况下就会出现这三个关键字段
• WATCHDOG KILLING SYSTEM PROCESS

grep -rn "ANR in\|ANRManager: Reason:\|ANRManager: Android time\|am_anr\|WATCHDOG KILLING SYSTEM PROCESS\| iowait\| Blocked\| held by thread\| waiting to lock"

# sublime
ANR in|Reason:|Android time|am_anr|WATCHDOG KILLING SYSTEM PROCESS| iowait| Blocked| held by thread| waiting to lock

# 高效的过滤命令，虽然grep很好用，文件超大的时候还是ag速度快
ag "ANR in|ANRManager: Reason:|ANRManager: Android time|am_anr|WATCHDOG KILLING SYSTEM PROCESS| iowait| Blocked| held by thread| waiting to lock"  

参考文档

• ANRs
• Android ANR日志分析指南
• 看完这篇 Android ANR 分析，就可以和面试官装逼了！
• Android - how do I investigate an ANR?
• 如何分析ANR Log的总结
• 给解决问题ANR一个印象
• Android ANR分析详解
• Android ANR：原理分析及解决办法

this view is not available until indices are built

怎么去解决这个问题呢。在jetbrains论坛找到了解决方案。实现ToolWindowFactory接口的同时还需要实现DumbAware接口，这样就不需要等项目同步完成了。

public class DevToolFactory implements ToolWindowFactory, DumbAware {  
    @Override
    public void createToolWindowContent(@NotNull Project project, @NotNull ToolWindow toolWindow) {
        MainComponent.getInstance(project).initView(toolWindow);
    }
}

参考文档

• Keeping tool window enabled while IDEA in "dumb" mode

• 腾讯云主机Python3环境安装Scrapy爬虫框架过程及常见错误
• scrapy 爬虫框架入门案例详解

常见问题

• No module named _util

pip install Twisted==16.4.1  

参考文档

• Scrapy连接到各类数据库(SQLite,Mysql,Mongodb,Redis)

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。

Example

// Person.java
public interface Person {  
    void eat(String food);
}

// Main.java
public class Man implements Person {

    private String name;

    public Man(String name) {
        this.name = name;
    }

    @Override
    public void eat(String food) {
        System.out.println(this.name + " eat " + food);
    }
}

// InvokeProxy.java
public class InvokeProxy<T> implements InvocationHandler {

    private T t;

    public InvokeProxy(T t) {
        this.t = t;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(this.t, args);
    }
}

// Test.java
Person person = new Man("One");  
Object object = Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[]{Person.class},new InvokeProxy<>(person));  
        if (object instanceof Person) {
            ((Person) object).eat("appl");
        }

原理分析

动态代理最关键方法是Proxy.newProxyInstance, 我们先看下这个方法源码

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,  
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        // #1 关键方法，生成新的class文件
        Class<?> cl = getProxyClass0(loader, intfs);

        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
              // #2 获取新建class的构造函数，生成的class构造函数参数是InvocationHandler
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            // #3 调用构造函数创建新对象
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

然后再来分析下getProxyClass0(loader, intfs)

private static Class<?> getProxyClass0(ClassLoader loader,  
                                           Class<?>... interfaces) {
        return proxyClassCache.get(loader, interfaces);
    }

// proxyClassCache 是一个 java.lang.reflect.WeakCache对象, 传递了两个参数KeyFactory, ProxyClassFactory

proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory()); 

// 获取和创建内容都在get方法里面, 注意这里key传的classloader， 第二个参数是接口的class对象，里面包含各种缓存机制，我们主要看下创建方法

...
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));  
Supplier<V> supplier = valuesMap.get(subKey);  
Factory factory = null;

while (true) {  
if (supplier != null) {  
   // supplier might be a Factory or a CacheValue<V> instance
   V value = supplier.get();
   if (value != null) {
       return value;
   }
}
...
supplier 是之前构造WeakCache构造函数传过来的ProxyClassFactory对象，supplier.get()执行了 ProxyClassFactory#apply(ClassLoader loader, Class<?>[] interfaces) 

// 然后重点看下java.lang.reflect.Proxy.ProxyClassFactory#apply   
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(  
                proxyName, interfaces, accessFlags);
try {  
   return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
}
// 主要调用ProxyGenerator.generateProxyClass 生成class文件内容，然后defineClass0写入文件。
private static native Class<?> defineClass0(ClassLoader loader, String name,  
                                                byte[] b, int off, int len);
// defineClass0是一个native方法，没有搜索它的c层的实现。我们来看下ProxyGenerator.generateProxyClass生成的内容到底是咋样的。

系统生成的class直接在内存，所以看不到class文件，我们可以自己写个demo写入文件

byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Man.class.getInterfaces());  
        String path = "./Man.class";
        try(FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(classFile);
            fos.flush();
            System.out.println("代理类class文件写入成功");
        } catch (Exception e) {
            System.out.println("写文件错误");
        }

文件内容如下

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import com.baidu.searchbox.proxy.Person;  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Person {  
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void eat(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.baidu.searchbox.proxy.Person").getMethod("eat", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

一个继承自Proxy实现Person接口的类，里面所有的方法都是通过调用构造函数里面InvocationHandler#invoke来实现的，这就回到了之前我们自己创建的InvocationHandler类，第一个参数是生成的对象，第二个是当前Method，第三个调用方法传递参数的数组，到这里动态代理逻辑就比较清楚了。

模式实践(实现简单的retrofit)

首先实现两个简单的注解

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Get {  
    String value();
}

@Documented
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Query {  
    String value();
}

写一个接口来定义方法

public interface ServerAPI {  
    @Get("https://www.baidu.com/")
    String getBaiduHome(@Query("type") String type);

    @Get("https://www.qq.com/")
    String getQQHome(@Query("type") String type);
}

生成接口的方法， 简单的输出了接口定义的参数

public class APIManager {

    @NotNull
    public static <T> T create(Class<T> tClass) {
        Object result = Proxy.newProxyInstance(tClass.getClassLoader(), new Class[]{tClass}, (proxy, method, args) -> {
            Get getAnnotation = method.getAnnotation(Get.class);
            if (getAnnotation == null) {
                return null;
            }
            String url = getAnnotation.value();
            String type = (String) args[0];
            return "method=" + method.getName() + ", url=" + url + ", type=" + type;
        });
        return (T) result;
    }
}

调用demo

String response = APIManager.create(ServerAPI.class).getBaiduHome("aaa");  
System.out.println(response);  
response = APIManager.create(ServerAPI.class).getQQHome("bbb");  
System.out.println(response);

// 运行结果
method=getBaiduHome, url=https://www.baidu.com/, type=aaa  
method=getQQHome, url=https://www.qq.com/, type=bbb  

小结

• 方便在不修改原代码的情况下扩展方法 (需要继承同一个接口)
• 像retrofit一样，动态且批量对接口进行处理
• 待补充

参考文档

• java动态代理实现与原理详细分析
• 动态代理+注解(DynamicProxyAndAnnotations)
• java动态代理原理源码解析（jdk8)

git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch 删除文件的相对路径' --prune-empty --tag-name-filter cat -- --all

git push origin master --force

rm -rf .git/refs/original/

git reflog expire --expire=now --all

git gc --prune=now

git gc --aggressive --prune=now  

不记得这段代码从哪复制了，感谢原作者的无私奉献，(*/ω＼*)~

计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。也就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。

举个简单的例子，比如下面的这段代码：i = i + 1;当线程执行这个语句时，会先从主存当中读取i的值，然后复制一份到高速缓存当中，然后CPU执行指令对i进行加1操作，然后将数据写入高速缓存，最后将高速缓存中i最新的值刷新到主存当中。

这个代码在单线程中运行是没有任何问题的，但是在多线程中运行就会有问题了。在多核CPU中，每条线程可能运行于不同的CPU中，因此每个线程运行时有自己的高速缓存（对单核CPU来说，其实也会出现这种问题，只不过是以线程调度的形式来分别执行的）。本文我们以多核CPU为例。比如同时有2个线程执行这段代码，假如初始时i的值为0，那么我们希望两个线程执行完之后i的值变为2。但是事实会是这样吗？

可能存在下面一种情况：初始时，两个线程分别读取i的值存入各自所在的CPU的高速缓存当中，然后线程1进行加1操作，然后把i的最新值1写入到内存。此时线程2的高速缓存当中i的值还是0，进行加1操作之后，i的值为1，然后线程2把i的值写入内存。最终结果i的值是1，而不是2。这就是著名的缓存一致性问题。通常称这种被多个线程访问的变量为共享变量。也就是说，如果一个变量在多个CPU中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。

为了解决缓存不一致性问题，通常来说有以下2种解决方法：

• 通过在总线加LOCK#锁的方式
• 通过缓存一致性协议

这2种方式都是硬件层面上提供的方式。

在早期的CPU当中，是通过在总线上加LOCK#锁的形式来解决缓存不一致的问题。因为CPU和其他部件进行通信都是通过总线来进行的，如果对总线加LOCK#锁的话，也就是说阻塞了其他CPU对其他部件访问（如内存），从而使得只能有一个CPU能使用这个变量的内存。比如上面例子中 如果一个线程在执行 i = i +1，如果在执行这段代码的过程中，在总线上发出了LCOK#锁的信号，那么只有等待这段代码完全执行完毕之后，其他CPU才能从变量i所在的内存读取变量，然后进行相应的操作。这样就解决了缓存不一致的问题。但是上面的方式会有一个问题，由于在锁住总线期间，其他CPU无法访问内存，导致效率低下。

所以就出现了缓存一致性协议。最出名的就是Intel 的MESI协议，MESI协议保证了每个缓存中使用的共享变量的副本是一致的。它核心的思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

并发编程中的三个概念

1.原子性

原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

一个很经典的例子就是银行账户转账问题：比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。 试想一下，如果这2个操作不具备原子性，会造成什么样的后果。假如从账户A减去1000元之后，操作突然中止。然后又从B取出了500元，取出500元之后，再执行 往账户B加上1000元 的操作。这样就会导致账户A虽然减去了1000元，但是账户B没有收到这个转过来的1000元。

所以这2个操作必须要具备原子性才能保证不出现一些意外的问题。同样地反映到并发编程中会出现什么结果呢？举个最简单的例子，大家想一下假如为一个32位的变量赋值过程不具备原子性的话，会发生什么后果？i = 9;假若一个线程执行到这个语句时，我暂且假设为一个32位的变量赋值包括两个过程：为低16位赋值，为高16位赋值。 那么就可能发生一种情况：当将低16位数值写入之后，突然被中断，而此时又有一个线程去读取i的值，那么读取到的就是错误的数据。

2.可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

举个简单的例子，看下面这段代码：

//线程1执行的代码
int i = 0;  
i = 10;

//线程2执行的代码
j = i;  

假若执行线程1的是CPU1，执行线程2的是CPU2。由上面的分析可知，当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。

此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.

这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

3.有序性

有序性：即程序执行的顺序按照代码的先后顺序执行。

int i = 0;  
boolean flag = false;  
i = 1;                //语句1  
flag = true;          //语句2  

上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序（Instruction Reorder）。

下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？再看下面一个例子：

int a = 10;    //语句1  
int r = 2;    //语句2  
a = a + 3;    //语句3  
r = a*a;     //语句4  

这段代码有4个语句，那么可能的一个执行顺序是：

那么可不可能是这个执行顺序呢： 语句2 -> 语句1 -> 语句4 -> 语句3

不可能，因为处理器在进行重排序时是会考虑指令之间的数据依赖性，如果一个指令Instruction 2必须用到Instruction 1的结果，那么处理器会保证Instruction 1会在Instruction 2之前执行。

虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：

//线程1:
context = loadContext();   //语句1  
inited = true;             //语句2

//线程2:
while(!inited ){  
  sleep()
}
doSomethingwithconfig(context);  

上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。

从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

深入剖析volatile关键字

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

• 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
• 禁止进行指令重排序。

注意：volatile并不能保证原子性

public class Test {  
    public volatile int inc = 0;

    public void increase() {
        inc++;
    }

    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }

        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

大家想一下这段程序的输出结果是多少？也许有些朋友认为是10000。但是事实上运行它会发现每次运行结果都不一致，都是一个小于10000的数字。

可能有的朋友就会有疑问，不对啊，上面是对变量inc进行自增操作，由于volatile保证了可见性，那么在每个线程中对inc自增完之后，在其他线程中都能看到修改后的值啊，所以有10个线程分别进行了1000次操作，那么最终inc的值应该是1000*10=10000。

这里面就有一个误区了，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

在前面已经提到过，自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：

假如某个时刻变量inc的值为10，

线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；

然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。

然后线程1接着进行加1操作，由于已经读取了inc的值，注意此时在线程1的工作内存中inc的值仍然为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。

那么两个线程分别进行了一次自增操作后，inc只增加了1。

解释到这里，可能有朋友会有疑问，不对啊，前面不是保证一个变量在修改volatile变量时，会让缓存行无效吗？然后其他线程去读就会读到新的值，对，这个没错。这个就是上面的happens-before规则中的volatile变量规则，但是要注意，线程1对变量进行读取操作之后，被阻塞了的话，并没有对inc值进行修改。然后虽然volatile能保证线程2对变量inc的值读取是从内存中读取的，但是线程1没有进行修改，所以线程2根本就不会看到修改的值。

根源就在这里，自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。

为什么double check单例需要加volatile?

在多线程环境中，volatile能保证共享变量的可见性以及一定程度的有序性。下面是一个double check的单例写法：

public class Singleton{  
    private static volatile Singleton instance = null;

    private Singleton(){}

    public Singleton getInstance(){
        if(null == instance){
            synchronized(Singleton.class){
                if(null == instance){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

因为volatile的可见性？比如线程1和线程2同时进入外层check，如果没有volatile关键字，因为线程的工作内存(register和CPU的L1、L2级缓存)的关系，导致不同的线程缓存了instance的副本，线程1对线程2的修改不可见？是这样的吗？答案：不是。因为instance是static变量，存在于方法区，对于线程而言是共享的，即线程不会缓存static变量

因为volatile的禁止指令重排序，在第10步中，初始化instance对象并非原子操作，它包括：1.开辟堆内存 2.调用构造方法初始化对象；如果没有volatile关键字，且在高并发情况下，如果某个线程开辟了堆内存后还未完成构造时，此时另一个线程进入外层判空后后发现instance对象非空，就返回了未构造完全的instance对象；volatile的意义在于能够禁止对当前对象进行指令的重排序，也就是happen-before原则的关于volatile的一条："volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作"，也就是说，无论什么情况，对于volatile变量的写操作必须在完成后才能读取，所以不会出现未完成构造就读取的情况；但是volatile不能保证同时对变量的写操作也是有序的，也就是volatile不能保证原子性

volatile的原理和实现机制

下面这段话摘自《深入理解Java虚拟机》：

“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

• 它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
• 它会强制将对缓存的修改操作立即写入主存；
• 如果是写操作，它会导致其他CPU中对应的缓存行无效。

参考文档

• Java并发编程：volatile关键字解析
• 单例模式与双重检测
• 单例模式的double check写法中的volatile关键字

文件目录在 应用程序 -> IDEA显示包内容找到 -> Contents -> bin -> idea.vmoptions

替换为如下内容:

-Xms1024m
-Xmx2048m
-XX:ReservedCodeCacheSize=1024m
-XX:+UseCompressedOops
-Dfile.encoding=UTF-8
-XX:+UseConcMarkSweepGC
-XX:SoftRefLRUPolicyMSPerMB=50
-ea
-Dsun.io.useCanonCaches=false
-Djava.net.preferIPv4Stack=true
-XX:+HeapDumpOnOutOfMemoryError
-XX:-OmitStackTraceInFastThrow
-Xverify:none
-XX:ErrorFile=$USER_HOME/java_error_in_idea_%p.log
-XX:HeapDumpPath=$USER_HOME/java_error_in_idea.hprof

开启内存提醒

参考文档

• 解决Mac环境下IntelliJ IDEA写代码卡顿情况，修改IntelliJ IDEA内存大小

<?xml version="1.0" encoding="utf-8"?>  
<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="26dp" android:width="26dp" android:viewportWidth="26" android:viewportHeight="26">  
    <path android:fillColor="#ee4f4f" android:pathData="M15.746,21.714C15.036,22.541 14.017,23.015 12.95,23.015C11.858,23.015 10.856,22.461 9.86,21.292L5.694,16.932L20.307,16.932L15.746,21.714ZM22.498,10.817C22.498,5.404 18.237,1 12.998,1C7.761,1 3.5,5.404 3.5,10.817L3.5,16.205C3.5,16.266 3.52,16.32 3.534,16.377C3.519,16.58 3.578,16.786 3.727,16.943L8.83,22.283C10.065,23.733 11.451,24.469 12.95,24.469C14.419,24.469 15.822,23.817 16.773,22.708L22.213,17.005C22.336,16.877 22.395,16.711 22.406,16.544C22.459,16.441 22.498,16.329 22.498,16.205L22.498,10.817Z" android:strokeColor="#00000000" android:strokeWidth="1"/>
</vector>  

我们这篇文章主角是小程序，在小程序上怎么使用svg呢？只能通过svg转成base64，然后显示出来。还有另一种就是我们这篇要介绍的，直接把svg转png图片。

VectorDrawable是Android专用的格式，严格意义上说并不是svg，不过总体上是一致的，可以通过替换标签来转换。

#VectorDrawable2Svg.py

"""
VectorDrawable2Svg  
This script convert your VectorDrawable to a Svg  
Author: Alessandro Lucchet

Usage: drop one or more vector drawable onto this script to convert them to svg format  
"""

from xml.dom.minidom import *  
import sys

# extracts all paths inside vdContainer and add them into svgContainer
def convertPaths(vdContainer,svgContainer,svgXml):  
    vdPaths = vdContainer.getElementsByTagName('path')
    for vdPath in vdPaths:
        # only iterate in the first level
        if vdPath.parentNode == vdContainer:
            svgPath = svgXml.createElement('path')
            svgPath.attributes['d'] = vdPath.attributes['android:pathData'].value
            if vdPath.hasAttribute('android:fillColor'):
                svgPath.attributes['fill'] = vdPath.attributes['android:fillColor'].value
            else:
                svgPath.attributes['fill'] = 'none'
            if vdPath.hasAttribute('android:strokeLineJoin'):
                svgPath.attributes['stroke-linejoin'] = vdPath.attributes['android:strokeLineJoin'].value
            if vdPath.hasAttribute('android:strokeLineCap'):
                svgPath.attributes['stroke-linecap'] = vdPath.attributes['android:strokeLineCap'].value
            if vdPath.hasAttribute('android:strokeMiterLimit'):
                svgPath.attributes['stroke-miterlimit'] = vdPath.attributes['android:strokeMiterLimit'].value
            if vdPath.hasAttribute('android:strokeWidth'):
                svgPath.attributes['stroke-width'] = vdPath.attributes['android:strokeWidth'].value
            if vdPath.hasAttribute('android:strokeColor'):
                svgPath.attributes['stroke'] = vdPath.attributes['android:strokeColor'].value
            svgContainer.appendChild(svgPath);

# define the function which converts a vector drawable to a svg
def convertVd(vdFilePath):

    # create svg xml
    svgXml = Document()
    svgNode = svgXml.createElement('svg')
    svgXml.appendChild(svgNode);

    # open vector drawable
    vdXml = parse(vdFilePath)
    vdNode = vdXml.getElementsByTagName('vector')[0]

    # setup basic svg info
    svgNode.attributes['xmlns'] = 'http://www.w3.org/2000/svg'
    svgNode.attributes['width'] = vdNode.attributes['android:viewportWidth'].value
    svgNode.attributes['height'] = vdNode.attributes['android:viewportHeight'].value
    svgNode.attributes['viewBox'] = '0 0 {} {}'.format(vdNode.attributes['android:viewportWidth'].value, vdNode.attributes['android:viewportHeight'].value)

    # iterate through all groups
    vdGroups = vdXml.getElementsByTagName('group')
    for vdGroup in vdGroups:

        # create the group
        svgGroup = svgXml.createElement('g')

        # setup attributes of the group
        if vdGroup.hasAttribute('android:translateX'):
            svgGroup.attributes['transform'] = 'translate({},{})'.format(vdGroup.attributes['android:translateX'].value,vdGroup.attributes['android:translateY'].value)

        # iterate through all paths inside the group
        convertPaths(vdGroup,svgGroup,svgXml)

        # append the group to the svg node
        svgNode.appendChild(svgGroup);

    # iterate through all svg-level paths
    convertPaths(vdNode,svgNode,svgXml)

    # write xml to file
    svgXml.writexml(open(vdFilePath + '.svg', 'w'),indent="",addindent="  ",newl='\n')

# script begin
if len(sys.argv)>1:  
    iterArgs = iter(sys.argv)
    next(iterArgs) #skip the first entry (it's the name of the script)
    for arg in iterArgs:
        convertVd(arg)
else:  
    print("You have to pass me something")
    sys.exit()

这是从stackOverFlow下载的脚本，原作者已经找不到，在此致谢。使用方式的话在代码里有说明。python VectorDrawable2Svg.py <需要转换的文件> 下面是转换后的svg代码:

<?xml version="1.0" ?>  
<svg height="26" viewBox="0 0 26 26" width="26" xmlns="http://www.w3.org/2000/svg">  
  <path d="M15.746,21.714C15.036,22.541 14.017,23.015 12.95,23.015C11.858,23.015 10.856,22.461 9.86,21.292L5.694,16.932L20.307,16.932L15.746,21.714ZM22.498,10.817C22.498,5.404 18.237,1 12.998,1C7.761,1 3.5,5.404 3.5,10.817L3.5,16.205C3.5,16.266 3.52,16.32 3.534,16.377C3.519,16.58 3.578,16.786 3.727,16.943L8.83,22.283C10.065,23.733 11.451,24.469 12.95,24.469C14.419,24.469 15.822,23.817 16.773,22.708L22.213,17.005C22.336,16.877 22.395,16.711 22.406,16.544C22.459,16.441 22.498,16.329 22.498,16.205L22.498,10.817Z" fill="#ee4f4f" stroke="#00000000" stroke-width="1"/>
</svg>

通过这个脚本，我们就可以把VectorDrawable转换成SVG了，在mac上也可以预览了。怎么转成图片呢？我们借助一些第三方工具。网上找了很多工具，觉得最好用的还是Boxy SVG。

软件的用法就不介绍了，都是界面化操作，基本没啥难度。到此就把VectorDrawable转成png了

There were xx failed login attempts since the last successful login.

有人在用错误的密码在尝试登录服务器，想想就有点方。网上的解决方案是用ssh密钥登录，关闭root的方式登录。下面记录下操作方式

配置密钥登录

腾讯云管理后台可以选择加载密钥，不过得先关机。创建密钥后就会下载得到一个密钥文件(后续需要这个登录)

创建新用户

adduser user1  
passwd user1  

配置服务器关闭ROOT登录

vim /etc/ssh/sshd_config

查找“#PermitRootLogin yes”，将前面的“#”去掉，短尾“yes”改为“no”，并保存文件。
# PermitRootLogin no，千万不要修改成No，linux是严格区分大小写的

# 重启服务
service sshd restart  

secureCRT 登录

操作完成后再尝试ssh登录就提示 Permission denied

ssh root@118.24.5.247 root@118.24.5.247: Permission denied (publickey,gssapi-keyex,gssapi-with-mic).

参考文档

• Centos 禁止root帐号直接登录

小程序录制的语音格式是aar和mp3, 如果想语音文本识别，像百度语音等SDK要求的都是无损原声pcm格式(wav仅仅是pcm的封装)，下面提供两种将mp3转换为wav的方法

0x1通过第三方接口

<?php  
$url = 'http://server.com/sound.mp3';
$data = json_decode(file_get_contents('http://api.rest7.com/v1/sound_convert.php?url=' . $url . '&format=wav'));

if (@$data->success !== 1)  
{
    die('Failed');
}
$wave = file_get_contents($data->file);
file_put_contents('sound.wav', $wave);  

0x2通过mpg123

服务器上安装mpg123

apt-get install mpg123  
// or
yum install mpg123  

执行shell转化

mpg123 -w output.wav input.mp3  

拿到wav格式就可以愉快的语音识别啦~

百度的语音识别不限制调用次数，文档请看这里: 百度语音sdk文档

参考文档

• linux convert mp3 to wav
• mp3 to wav on linux via PHP
• Convert MP3 to WAV in PHP

这是一款看漂亮小姐姐的小程序，开源地址是: https://github.com/pengwei1024/HiBeauty。话不多说，先上个截图各位小主看看合不合胃口。

怎么抱走小姐姐呢?

可以微信小程序搜索 唯美小姐姐 或者扫码抱走吧

0x2原理分析

各位小主看完了小姐姐，请把口水擦干，我们来看看怎么new一个小姐姐吧。我觉得技术点主要下面两个(当然第一个才是大家最关心的)：

• 小姐姐数据的抓取和处理
• 小程序从服务器拉取并展示数据

数据抓取

小姐姐的数据主要来自微博美女帅哥大V, 如x粉大魔王等等，在此向各位辛勤付出的大V致谢。抓取用的方案是Headless Chrome + selenium,简而言之就是用的服务器上web自动化方案。

为什么采用这个方案呢，直接抓取网页的方式帐号容易被封，自动登录获取cookie的技术难度都比较大。而web自动化就是模拟网页点击，一切的操作都是so easy。

不了解 Headless Chrome 和 selenium？请看下面的教程:

• 安装Headless Chrome
• selenium教程

linux上配置一个定时任务，实现全自动化的抓取，再来个图片分类器把非小姐姐图片去除，自动更新，开开心心欣赏小姐姐真是美滋滋

用selenium抓取的代码不会超过50行，这里就不展开了，各位小主自己尝试下吧~

图片展示

小程序展示列表实在不是什么技术难点，如果说有什么需要注意的话，那就是图片可以持续下拉加载更多，数据量过大导致OOM崩溃的问题, 主要分两步解决吧。

• 图片不直接加载原图 (微博提供了缩略图和原图两套)
• 增量刷新列表

重点来看下小程序增量刷新列表吧。(会的大哥大姐可以忽略，毕竟我是一个小菜鸟) 更新的时候加上下标就好了。

this.setData({  
    'array[0].text':'changed data'
})

用了某网友分享的一个类SafeRenderUtil, 自己新增了一个reset方法, 找不到原作者链接了，在此致谢

/**
 * @module SafeRenderUtil
 */

/**
 * 安全渲染的工具类
 * 解决的问题：分页加载时，数组拼接起来在渲染，当数据超过 1M 后，无法再加载
 * @example
 * import SafeRenderUtil from '@xxx/lib/safeRenderUtil';
 * // 初始化
 * this.SafeRenderUtil = new SafeRenderUtil({
 *   arrName: 'arrName',
 *   formatItem: (item) => {
 *     //裁剪每一项的图片...
 *     return item;
 *   },
 *   setData: this.setData.bind(this)
 * });
 * // 将数组传递进来进行渲染
 * this.SafeRenderUtil.addList(res.data.data);
 */
class SafeRenderUtil {  
  /**
   * @param {String} opts.arrName 数组名称
   * @param {Function} opts.formatItem 处理数组的每一个 item ，并将该 item 返回
   * @param {Function} opts.setData 调用页面的渲染方法
   */
  constructor(opts) {
    this.arrName = opts.arrName;
    this.formatItem = opts.formatItem;
    this.setData = opts.setData;
    this.originLen = 0; //原始数组长度
  }
  /**
   * @param {Array} arr 需要渲染的数组
   */
  addList(arr) {
    if (arr && arr.length) {
      let newList = {};
      for (let i = 0; i < arr.length; i++) {
        let item = arr[i];
        if (typeof(this.formatItem) === 'function') {
          item = this.formatItem(item);
        }
        newList[`${this.arrName}[${this.originLen}]`] = item;
        this.originLen += 1;
      };
      this.setData(newList);
    }
  }
  /**
   * 清空数组数据
   */
  clearArr() {
    this.setData({
      [`${this.arrName}`]: []
    });
    this.originLen = 0;
  }

  reset(arr) {
    this.originLen = arr.length;
    if (arr && arr.length) {
      for (let i = 0; i < arr.length; i++) {
        if (typeof(this.formatItem) === 'function') {
          arr[i] = this.formatItem(arr[i]);
        }
      };
      this.setData({
        [`${this.arrName}`]: arr
      });
    }
  }
}
module.exports = SafeRenderUtil;  

0x3 最后

本人代码不精,封装无力,架构松散，欢迎大家提建议、issue、pr。

微信技术交流群，欢迎交流

自定义task

task apkUpload(type: Exec, dependsOn: ['assembleRelease']) {  
    def version = project.android.defaultConfig.versionName
    def apkPath = "$buildDir/outputs/apk/release/app-release.apk"
    commandLine "curl", "-F", "apk=@$apkPath", "上传地址"
}

创建了一个Exec类型的task, 依赖assembleRelease任务, 最后执行shell curl -f apk=@{文件路径} {上传路径} 来完成上传

服务器示例 (PHP Codeigniter)

/**
     * 上传apk
     * @param $version
     */
    public function upload($version)
    {
        $config['upload_path'] = FCPATH . 'apks/';
        $config['allowed_types'] = '*';
        $config['file_name'] = "beauty_$version.apk";
        $config['max_size'] = 1024 * 10;
        $config['overwrite'] = true;
        $this->load->library('upload', $config);
        $this->upload->initialize($config);
        if ($this->upload->do_upload('apk')) {
            file_put_contents(FCPATH . 'apks/version', $version);
            echo "upload success!!";
        } else {
            echo $this->upload->display_errors();
            echo "upload failure!!";
        }
    }

直接运行安装脚本

curl https://intoli.com/install-google-chrome.sh | bash  

安装完成后会提示:

Successfully installed google-chrome-stable, Google Chrome 65.0.3325.146 .

运行chrome

google-chrome-stable --no-sandbox --headless --disable-gpu --screenshot     https://www.baidu.com  

正常的话会在当前目录生成screenshot.png的文件

驱动
下载chrome驱动并放到某个目录下: http://npm.taobao.org/mirrors/chromedriver/2.36/chromedriver_linux64.zip , 运行./chromedriver, 如果能返回下面内容说明驱动安装正常

Starting ChromeDriver 2.36.540471 (9c759b81a907e70363c6312294d30b6ccccc2752) on port 9515 Only local connections are allowed.

selenium 使用

from selenium import webdriver

options = webdriver.ChromeOptions()  
options.binary_location = '/usr/bin/google-chrome-stable'  
options.add_argument('--headless')  
options.add_argument('--disable-gpu')  
options.add_argument('--no-sandbox')  
options.add_argument('window-size=1200x600')  
driver = webdriver.Chrome(chrome_options=options, executable_path='/opt/drivers/chromedriver')  
driver.get('https://facebook.com')  
print driver.title  
driver.quit()  

centos 6 安装

貌似是因为chrome 不支持centos 6，所以没有找到好的安装教程，那就试试firefox吧，整体上也不错

# 安装Xvfb和pyvirtualdisplay
yum install xorg-x11-server-Xvfb  
pip install pyvirtualdisplay

# 安装firefox和selenium
yum install firefox  
pip install selenium

# 注意selenium 3+ 只支持python3， 如果本地是python2 需要安装selenium 2.x
pip install selenium==2.44.0  

测试代码

from pyvirtualdisplay import Display  
from selenium import webdriver

display = Display(visible=0, size=(800, 600))  
display.start()

browser = webdriver.Firefox()  
browser.get('http://www.google.com')  
print browser.title  
browser.quit()

display.stop()  

我按这个教程安装一直报错：

raise WebDriverException("The browser appears to have exited " selenium.common.exceptions.WebDriverException: Message: The browser appears to have exited before we could connect. If you specified a log_file in the FirefoxBinary constructor, check it for details.

看教程说要手动启动 Xvfb, 请参考这里

Xvfb :19 -screen 0 1024x768x16 &

DISPLAY=:19 firefox "http://www.yahoo.com"  

这样错误变成了 /var/lib/dbus/machine-id找不到

yum install dbus

dbus-uuidgen > /var/lib/dbus/machine-id  

参考文档

• CentOS 7.x环境下搭建: Headless chrome + Selenium + ChromeDriver 实现自动化测试
• linux无界面(headless)使用selenium抓取数据
• Install headless Firefox on CentOS 6 for Selenium automation.md
• RUNNING SELENIUM WITH HEADLESS CHROME
• Python selenium.webdriver.ChromeOptions() Examples

# 使用json_last_error输出错误信息
var_dump(json_last_error());

# 发现错误码是5 JSON_ERROR_UTF8, 转成uft-8就好了
mb_convert_encoding($value, "UTF-8", "auto");  

参考文档

• php json_encode输出空白问题
• How to solve JSONERRORUTF8 error in php json_decode?

[root@localhost ~]# ping google.com
ping: unknown host google.com

[root@localhost ~]# ping github.com
ping: unknown host github.com

[root@localhost ~]# ping baidu.com
ping: unknown host baidu.com  

一般这种情况都是DNS解析问题，但是不可能这些知名企业解析会出问题，所以联系搬瓦工客服咨询这个问题，以下是他们给的解决方案，成功解决了我的问题：

Hello,

The most common reason for broken network is an old NAT iptables rule. Whenever your VPS IP changes due to migration performed via KiwiVM, you need to either modify the old rules or delete them.

You can find more information about this by visiting the following article: https://bandwagonhost.com/knowledgebase.php?action=displayarticle&id=24

Thank you.

解决方案就是在shell执行一句话重置iptables：

iptables -F; iptables -t nat -F; iptables-save > /etc/sysconfig/iptables  

不需要重启任何东西就可以马上生效~

附: 替换IP方案

If you need to replace a banned IP with a clean IP, there are two options available to you:

* Option 1 * Free IP replacement. We allow you to replace a blacklisted IP with a clean IP for free, once every 10 weeks. To access this feature, first login to KiwiVM as usual, then access the following hidden page (copy+paste link into the browser's address bar):

https://kiwivm.64clouds.com/main-exec.php?mode=blacklistcheck

* Option 2 * Manual IP replacement (fees apply) available at the following link:

https://bandwagonhost.com/ipchange.php

mirror:

https://bwh1.net/ipchange.php

This is an automatic reply. If your request is not properly addressed, please reply in this ticket and one of our engineers will take a look.

注意：搬瓦工每10个星期(2.5个月)可以免费更换一次ip。