ue4主要是做什么用的？UE4，即虚幻4，它是一套为开发实时技术而存在的引擎工具。目前广泛应用于3D建模渲染、游戏开发中。它完善的工具套件以及简易的工作流程能够使开发者快速修改或查看成果，对于代码的依赖性很低。而完整公开的源代码则能让使用者自由修改和扩展引擎功能。
UE4开发引擎能够通过实时渲染，从NPC、人物角色、道具、AI等等方面很好地对游戏进行开发编辑。无论是关卡设计人员、美术开发人员、还是程序脚本编写人员，都能够通过UE4自由地对游戏的各个方面进行实时的调整与优化。这是3Dmax、maya这些软件无法实现的。
除此之外，整个UE4的引擎编辑器都可以在VR模式下运行，具备动作控制技术，让您能够在“所见即所得”的环境中进行创作，从而进行VR游戏、VR项目的开发。目前，它是世界上最稳健、功能最完善、最强大的VR开发解决方案。
相比于unity3D游戏开发引擎来说，UE4能够独立完成开发工作。这也就意味着，学会UE4软件，就能够独立承接开发项目。只要你懂得C++源代码，那么你就可以学习、自定义并调试整个引擎，并毫无阻碍地发行产品。
那么去哪里可以学习UE4开发技能呢？在这里我就给大家推荐火星时代的UE4引擎开发工程师课程。在这里，除去软件的基本操作外，火星时代的老师会帮助学习C++编程语言，并且学习是行业标准的编码格式，所以不论你有没有编程基础，都可以在这里从零开始学习。
而且火星时代还有着完善的就业保障措施，在毕业季，你就可以通过丰富的校园招聘会选择自己心仪的工作进行面试，免去奔波的疲惫。还有面试辅导、就业跟踪、教育培训保险等等方式为你保驾护航！如果想要了解更多，不如前来火星时代官网在线咨询老师！

区块链的集体维护可以降低成本
在中心化网络体系下，系统的维护和经营依赖于数据中心等平台的运维和经营，成本不可省略。区块链的节点是任何人都可以参与的，每一个节点在参与记录的同时也来验证其他节点记录结果的正确性，维护效率提高，成本降低。

一句话概括，区块链触动的是钱、信任和权力，这些人类赖以生存的根本性基础。
区块链的核心是分布式账本技术，有加密算法，有共识机制，有点对点网络，有激励机制等。区块链通过分布式的节点支撑起真正的点对点沟通，做到去中介化的信任。
区跨链是第一个能够真正做到去中介化信任的技术，这意味无须经过任何第三方的共享经济成为可能。
共享经济遇到了区块链，就是春风遇到了雨，可以萌生出真正的共享经济，改变之前共享经济停留在概念，停留在租赁经济上的现状。这也是区块链可以带给这个世界的新东西，必然对商业组织和形态产生重大的影响。

1、为什么要进行启动优化

一款应用的第一印象很重要，第一印象往往决定了用户的去留。打开一款应用，如果速度很快，很顺畅，那么很容易让人觉得这款应用背后的技术实力很强，用户潜意识中会对这款应用更加的信赖。

其次，网上也流行一种说法，就是8秒定律，意思是说，如果用户在打开一个页面，在8秒的时间内还没有打开，那么用户大概的会放弃掉，意味着一个用户的流失。从这里就可以看出，启动优化的重要性了。

2、启动的分类

2.1 冷启动

先来看看冷启动的流程图


从图中可以看出，APP启动的过程是：ActivityManagerProxy 通过IPC来调用AMS（ActivityManagerService），AMS通过IPC启动一个APP进程，ApplicationThread通过反射来创建Application并且绑定，最后通过ActivityThread来控制activity的生命周期，在相关页面的生命周期中通过ViewRootImpl来对view的实现。从而完成应用的启动。

2.2 热启动

热启动的速度是最快的，它就是进程从后台切换到前台的一个过程。

2.3 温启动

温启动只会重新走一遍页面的生命周期，但是对于进程，application不会重新在创建。

3、优化方向

上面介绍了启动的几种方式可以看出，我们针对启动优化，基本只是优化冷启动就可以了。但是从冷启动的启动流程中很多都是系统做的，我们没有办法操控。我们能做的，就是application的生命周期和activity的生命周期这部分，启动优化往往就是从这两块入手。

4、启动时间的测量方式

4.1 使用adb 命令方式（线下使用方便）

adb shell am start -W 包名/包名+类名




ThisTime:最后一个activity的启动耗时

TotalTime：所有activity的启动耗时

WaitTime:AMS启动activity的总耗时

这里由于我直接进入到主界面，中间并没有SplashActivity，所有ThisTime 和 TotalTime的时间是一样的

优势：在线下使用方便，适合于跑线下的产品，和获取竞品的时间，然后比对

缺点：不能带到线上，获取的时间，只能说是一个大概时间，不是很严谨。

4.2 手动打点方式



通过System.currentTimeMillis()来打时间戳

缺点：很明显，对代码侵入性非常的大，如果说我想要打出每一个任务花费的时间，那么代码看起来就很恶心了

5、优雅获取方法耗时

5.1 AOP Aspect Oriented Programming 面向切面编程

AOP：通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。它的核心思想就是将应用程序中的业务逻辑处理部分同对其提供通用服务部分即“横切关注点”进行分离。

OOP：引入封装，继承，多态等概念来建立一种对象层次结构，它允许开发者定义纵向的关系，但并不适合横向的关系。

可以说AOP是OOP的一种补充和完善。

5.2 aspectj的使用

AspectJ是一个面向切面编程的框架，是对java的扩展且兼容java，AspectJ定义了AOP语法，它有一个专门的编译器来生成遵守java字节编码规范的Class文件。

在项目的根目录的build.gradle添加依赖：

dependencies { www.yuntianyul.com
        classpath 'com.android.tools.build:gradle:3.5.2'
        classpath 'com.hujiang.aspectjx:gradle-android-plugin-aspectjx:2.0.0'

        /www.jintianxuesha.com/ NOTE: Do not place your application dependencies here; they belong
        /www.yixingylzc.cn/ in the individual module build.gradle files
    }


在app下的build.gradle添加依赖

apply plugin: 'android-aspectjx'


在dependencies中添加

implementation 'org.aspectj:aspectjrt:1.9.4'


然后创建一个类

package com.noahedu.myapplication.aspectj;

import android.util.Log;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.www.jinliyld.cn lang.Signature;
import org.aspectj.www.iceason.net lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

/**
 * @Description:www.tengyao3zc.cn  www.anxinzc5.cn //@Before 在切入点之前运行
 * //    @After(www.ued3zc.cn    www.rhyl158.com "")
 *     //@Around 在切入点前后都运行
 * @Author: huangjialin
 * @CreateDate: www.keLezaix.com 2020/7/10 14:07
 */
@Aspect
public class MyApplicationAspectj {

    @Around("call(* com.noahedu.myapplication.MyApplication.**(..))")
    public void getTime(ProceedingJoinPoint joinPoint){
        Signature signature = joinPoint.getSignature();
        String name = signature.getName();
        long time = System.currentTimeMillis();
        try {
            joinPoint.proceed www.tainfengyue.cn  www.zhuyngyule.cn();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        Log.e("MyApplicationAspectj " ,(name + " cost " + (System.currentTimeMillis() - time)));
    }
}


这样我们运行的时候，就会直接在logcat中打印出application中的onCreate方法中所有调用方法的耗时情况了

2020-07-10 14:22:27.151 1619-1619/? E/MyApplicationAspectj: taskOne cost 150
2020-07-10 14:22:29.203 1619-1619/com.noahedu.myapplication E/MyApplicationAspectj: taskTwo cost 2052
2020-07-10 14:22:29.554 1619-1619/com.noahedu.myapplication E/MyApplicationAspectj: taskThrid cost 351
2020-07-10 14:22:30.556 1619-1619/com.noahedu.myapplication E/MyApplicationAspectj: taskFour cost 1001


这样我们几乎没有碰Application中的任何代码，也就够得出各个方法的耗时，几乎对代码无侵入。

6、启动优化的工具选择

6.1 traceview

TraceView是Android SDK中内置的一个工具，他可以加载trace文件，以图形化的形式展示相应代码的执行时间，次数及调用栈，便于我们分析。

 Debug.startMethodTracing("MyApplication");
      //TODO
 Debug.stopMethodTracing();


运行项目就可以我们的SD卡中找到对应的trace文件了，如果是Android studio可以直接在右下角找到

DeviceFileExporer -->sdcard --> Android -- > data -->files --->自己项目的包名

然后双击即可查看文件了

优点：使用简单，图形形式展示所执行的时间，调用栈等。

缺点：会影响到我们优化的方向，由于是图形化展示，也是比较占用CPU资源的，所以得到的时间往往是比实际的要大。

7、启动器

上面介绍了多了几个获取任务执行时间的方式和工具，那么当我们知道某个方法耗时了，我们该怎么处理呢？

package com.noahedu.myapplication;

import android.app.Application;
import android.os.Debug;
import android.util.Log;


/**
 * @Description: java类作用描述
 * @Author: huangjialin
 * @CreateDate: 2020/7/10 9:59
 */
public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        Debug.startMethodTracing("MyApplication");
        taskOne();
        taskTwo();
        taskThrid();
        taskFour();
        Debug.stopMethodTracing();
    }

    public void taskOne(){
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void taskTwo(){
        try {
            Thread.sleep(2050);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void taskThrid(){
        try {
            Thread.sleep(350);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void taskFour(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


现在application的onCreate方法中有几个任务，各个耗时是不一样的。可能很多同学就会说了，异步处理啊，开线程，放到线程池中，或者创建一个IntentService来执行。那么我们就要考虑几个问题了

第一：异步处理，如果在某个页面需要用到某个SDK，但是又没有初始化完成呢？

第二：假如说taskTwo需要taskOne的某个返回值呢？怎么保证taskOne在taskTwo之前执行完毕呢？

第三：开线程，开多少个线程呢？多了会造成资源浪费，少了资源又没有合理的利用。

我个人觉得针对于启动优化，在Application中的onCreate()进行初始化任务操作，我们首先需要对这些任务进行一个优先级划分，针对于那些优先级高的任务，我们可以优先进行处理，对于那些优先级较低的，我们可以适当的延迟进行加载。

其次有很多同学喜欢把那些优先级较低的任务进行延迟加载，比如new Handler().postDelayed()，这种我觉得是非常不可取的，假如说放在postDelayed中的任务耗时2s，延迟1s进行处理，那么在执行2s任务的过程中，有用户进行操作，那岂不是很卡吗，很明显，这是指标不治本的。

7.1 启动器的思想

针对上面说的几个痛点，怎么在处理上面的几个痛点，又能保证代码的可维护性呢？换句话说就是一个新人不需要理解整个过程，直接就可以开干呢？那么，启动器来了。

启动器核心思想：充分利用CPU多核，自动梳理任务顺序

7.2 启动器的原理

1、任务全部封装成Task对象，传入到集合中。

2、根据所有的任务依赖关系，形成一个有向无环图，然后通过拓扑排序排列出任务的执行流程

3、通过CountDownLatch来控制某一个任务是否执行完毕才进行下一步。

4、线程池创建核心线程的数量，由手机的核数量决定的。

7.3启动器使用方式



7.4启动器核心代码



进行任务排序

package com.noahedu.launchertool.launchstarter.sort;


import com.noahedu.launchertool.launchstarter.task.Task;
import com.noahedu.launchertool.launchstarter.utils.DispatcherLog;

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

import androidx.annotation.NonNull;
import androidx.collection.ArraySet;


public class TaskSortUtil {

    private static List<Task> sNewTasksHigh = new ArrayList<>();// 高优先级的Task

    /**
     * 任务的有向无环图的拓扑排序
     *
     * @return
     */
    public static synchronized List<Task> getSortResult(List<Task> originTasks,
                                                        List<Class<? extends Task>> clsLaunchTasks) {
        long makeTime = System.currentTimeMillis();

        Set<Integer> dependSet = new ArraySet<>();
        Graph graph = new Graph(originTasks.size());
        for (int i = 0; i < originTasks.size(); i++) {
            Task task = originTasks.get(i);
            if (task.isSend() || task.dependsOn() == null || task.dependsOn().size() == 0) {
                continue;
            }
            for (Class cls : task.dependsOn()) {
                int indexOfDepend = getIndexOfTask(originTasks, clsLaunchTasks, cls);
                if (indexOfDepend < 0) {
                    throw new IllegalStateException(task.getClass().getSimpleName() +
                            " depends on " + cls.getSimpleName() + " can not be found in task list ");
                }
                dependSet.add(indexOfDepend);
                graph.addEdge(indexOfDepend, i);
            }
        }
        List<Integer> indexList = graph.topologicalSort();
        List<Task> newTasksAll = getResultTasks(originTasks, dependSet, indexList);

        DispatcherLog.i("task analyse cost makeTime " + (System.currentTimeMillis() - makeTime));
        printAllTaskName(newTasksAll);
        return newTasksAll;
    }

    @NonNull
    private static List<Task> getResultTasks(List<Task> originTasks,
                                             Set<Integer> dependSet, List<Integer> indexList) {
        List<Task> newTasksAll = new ArrayList<>(originTasks.size());
        List<Task> newTasksDepended = new ArrayList<>();// 被别人依赖的
        List<Task> newTasksWithOutDepend = new ArrayList<>();// 没有依赖的
        List<Task> newTasksRunAsSoon = new ArrayList<>();// 需要提升自己优先级的，先执行（这个先是相对于没有依赖的先）
        for (int index : indexList) {
            if (dependSet.contains(index)) {
                newTasksDepended.add(originTasks.get(index));
            } else {
                Task task = originTasks.get(index);
                if (task.needRunAsSoon()) {
                    newTasksRunAsSoon.add(task);
                } else {
                    newTasksWithOutDepend.add(task);
                }
            }
        }
        // 顺序：被别人依赖的————》需要提升自己优先级的————》需要被等待的————》没有依赖的
        sNewTasksHigh.addAll(newTasksDepended);
        sNewTasksHigh.addAll(newTasksRunAsSoon);
        newTasksAll.addAll(sNewTasksHigh);
        newTasksAll.addAll(newTasksWithOutDepend);
        return newTasksAll;
    }

    private static void printAllTaskName(List<Task> newTasksAll) {
        if (true) {
            return;
        }
        for (Task task : newTasksAll) {
            DispatcherLog.i(task.getClass().getSimpleName());
        }
    }

    public static List<Task> getTasksHigh() {
        return sNewTasksHigh;
    }

    /**
     * 获取任务在任务列表中的index
     *
     * @param originTasks
     * @return
     */
    private static int getIndexOfTask(List<Task> originTasks,
                                      List<Class<? extends Task>> clsLaunchTasks, Class cls) {
        int index = clsLaunchTasks.indexOf(cls);
        if (index >= 0) {
            return index;
        }

        // 仅仅是保护性代码
        final int size = originTasks.size();
        for (int i = 0; i < size; i++) {
            if (cls.getSimpleName().equals(originTasks.get(i).getClass().getSimpleName())) {
                return i;
            }
        }
        return index;
    }
}



执行任务代码

package com.noahedu.launchertool.launchstarter.task;

import android.os.Looper;
import android.os.Process;

import com.noahedu.launchertool.launchstarter.TaskDispatcher;
import com.noahedu.launchertool.launchstarter.stat.TaskStat;
import com.noahedu.launchertool.launchstarter.utils.DispatcherLog;

/**
 * 任务真正执行的地方
 */

public class DispatchRunnable implements Runnable {
    private Task mTask;
    private TaskDispatcher mTaskDispatcher;

    public DispatchRunnable(Task task) {
        this.mTask = task;
    }
    public DispatchRunnable(Task task,TaskDispatcher dispatcher) {
        this.mTask = task;
        this.mTaskDispatcher = dispatcher;
    }

    @Override
    public void run() {
        DispatcherLog.i(mTask.getClass().getSimpleName()
                + " begin run" + "  Situation  " + TaskStat.getCurrentSituation());

        Process.setThreadPriority(mTask.priority());

        long startTime = System.currentTimeMillis();

        mTask.setWaiting(true);
        mTask.waitToSatisfy();

        long waitTime = System.currentTimeMillis() - startTime;
        startTime = System.currentTimeMillis();

        // 执行Task
        mTask.setRunning(true);
        mTask.run();

        // 执行Task的尾部任务
        Runnable tailRunnable = mTask.getTailRunnable();
        if (tailRunnable != null) {
            tailRunnable.run();
        }

        if (!mTask.needCall() || !mTask.runOnMainThread()) {
            printTaskLog(startTime, waitTime);

            TaskStat.markTaskDone();
            mTask.setFinished(true);
            if(mTaskDispatcher != null){
                mTaskDispatcher.satisfyChildren(mTask);
                mTaskDispatcher.markTaskDone(mTask);
            }
            DispatcherLog.i(mTask.getClass().getSimpleName() + " finish");
        }
    }

    /**
     * 打印出来Task执行的日志
     *
     * @param startTime
     * @param waitTime
     */
    private void printTaskLog(long startTime, long waitTime) {
        long runTime = System.currentTimeMillis() - startTime;
        if (DispatcherLog.isDebug()) {
            DispatcherLog.i(mTask.getClass().getSimpleName() + "  wait " + waitTime + "    run "
                    + runTime + "   isMain " + (Looper.getMainLooper() == Looper.myLooper())
                    + "  needWait " + (mTask.needWait() || (Looper.getMainLooper() == Looper.myLooper()))
                    + "  ThreadId " + Thread.currentThread().getId()
                    + "  ThreadName " + Thread.currentThread().getName()
                    + "  Situation  " + TaskStat.getCurrentSituation()
            );
        }
    }

}



基本核心代码就是上面这几个，完整的代码会在后面的demo给出

8、其他优化方案

8.1 对延迟任务进行分批初始化，使用IdleHandler特性，进行空闲执行 （适合优先级不是很高，不急于初始化的第三方SDK）

IdleHandler：IdleHandler 可以用来提升性能，主要用在我们希望能够在当前线程消息队列空闲时做些事情（譬如 UI 线程在显示完成后，如果线程空闲我们就可以提前准备其他内容）的情况下，不过最好不要做耗时操作。简单来说就是，looper对象有空的时候就会执行IdleHandler中的任务。

前面说过，在application的任务进行优先级划分，那么如果优先级低的任务，我们是不是可以不再application的onCreate中进行初始化呢？是否可以放到activity中进行呢？如果可以在activity中，那么在activity那个阶段适合呢？其实在onCreate()，onResume()都是可以的。当然我们也可以使用view中的getViewTreeObserver().addOnPreDrawListener进行监听，这个事件是视图将要绘制的时候会回调该方法。我们可以在回调的方法中将要初始化的SDK放大IdleHandler中。

8.2 提前加载SP 可以放到multidex之前加载，利用此阶段的CPU

SharedPreferences，以键值对的形式进行数据的保存的，会一次性加载到内存中，所以我们可以考虑那个阶段的CPU相对来说比较空闲。如可以放到multidex之前加载，充分利用此阶段的CPU进行

什么是区块链？
简单的来说可以把区块链看作一个去中心化的数据库，那什么又是去中心化呢？
    当然去中心化也不是不要中心的意思。
    简单地说，中心化的意思，是中心决定节点。节点必须依赖中心，节点离开了中心就无法生存。
    在去中心化系统中，任何人都是一个节点，任何人也都可以成为一个中心。任何中心都不是永久的，
    而是阶段性的，任何中心对节点都不具有强制性。
    然而这个去中心化的数据库不像传统数据库可以增删改查，它只有增和查的功能，意味着这个数据库会不断
    的增大，体现在区块在不断的增加。这也导致同步区块的数据文件将会越来越大。
    那什么又是智能合约呢？
    你可以把智能合约看成一些接口，然后这个接口呢可以存在去中心化的数据库上供人查看和调用，那为什么要用智能合约呢，
原因就是这个去中心化的数据库我们是无法修改和删除的，这也就意味着这个合约你也无法去修改，优势就是无法篡改性，通过这样一种机制可以保障信任机制。