在Android 插件化（加载插件）中，简单的用一个demo 讲了如何加载一个插件，并使用插件里的资源。

那如果我们的插件中有多个页面呢，要怎么办？

其实，也是很简单，还是通过外部 PluginActivity 的 startActivity来实现

一、LifeActivity的 startActivity

在LifeActivity 这个插件类中定义一个 startActivity 方法，用宿主的 context 调用 startActivity 方法

public void startActivity(Intent intent) {

    if (context != null) {

        if (intent==null||intent.getComponent()==null)return;

        Intent newIntent=new Intent();

        String className=intent.getComponent().getClassName();

        if (TextUtils.isEmpty(className))return;

        Log.e("startActivity","className="+className);

        newIntent.putExtra("className",intent.getComponent().getClassName());

        context.startActivity(newIntent);

    }

}

而对于第一个插件中的页面 TestActivity

可以看到，插件中的第一个页面 TestActivity 点击打开 插件页面 Test2Activity 时。写法跟我们在Android中的风格是一模一样的。其中的 findViewById 等，只要是用到上下文的，全部替换成宿主的，这里不多赘述了。

二、重写 PluginActivity 的 startActivity

注意：由于 Test2Activity 不是一个真正 Activity ,PluginActivity 的 startActivity 中，就不能打开这个页面，只能再重新打开一个PluginActivity，并将Test2Activity 类的信息再重新加载实例化一次，跟我们第一个加载TestActivity 是一样的。

override fun startActivity(intent: Intent?) {

    val className = intent?.getStringExtra("className")

    if (className.isNullOrBlank()) return

    val newIntent = Intent(this, PluginActivity::class.java)

    newIntent.putExtra("className", className)

    super.startActivity(newIntent)

}

传入进去的 className 就是 Test2Activity ，在PluginActivity 走生命周期onCreate 时，loadClassActivity ，至此就完成了插件内部的跳转，是不是非常简单。

三、同理，有 Activity 就会有其他组件

我们可以在插件中自己实现 service 、 ContentProvider、 BroadcastReceiver
等等组件，并重写生命周期等方法。原理都非常简单，难的是思想，这些都是插件化中的冰山一脚，我自己的项目中的更加复杂。

由于这样的方式，需要手动创建生命周期管理，和后续Activity启动模式，入栈出栈的管理等等。其实可以使用ASM等字节码来转换,将四大组件转成普通类，这样，开发过程中容易调试，插件生成也相对简单。

四、动态加载

由于插件apk 是可以从外部sdk 等地方加载的，给我们带来很多便利。而且插件部分的资源都是动态的，可以做到热更新的效果，只要我修改了再重新打包下发就行了。后续可以自己实现一套插件管理，用于加载外部apk ,做到热插拔的作用。

背景

在App开发过程中，我们经常需要自动重启的功能。比如：

• 登录或登出的时候，为了清除缓存的一些变量，比较简单的方法就是重新启动app。


• crash的时候，可以捕获到异常，直接自动重启应用。


• 在一些debug的场景中，比如设置了一些测试的标记位，需要重启才能生效，此时可以用自动重启，方便测试。

那我们如何实现自动重启的功能呢？我们都知道如何杀掉进程，但是当我们的进程被杀掉之后，如何唤醒呢？

这篇文章就来和大家介绍一下，实现应用自动重启的几种方法。

方法1 AlarmManager

    private void setAlarmManager(){

        Intent intent = new Intent();

        intent.setClass(this, MainActivity.class);

        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_ONE_SHOT);

        AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

        alarmManager.set(AlarmManager.RTC, System.currentTimeMillis()+100, pendingIntent);

        Process.killProcess(Process.myPid());

        System.exit(0);

    }

使用AlarmManager实现自动重启的核心思想：创建一个100ms之后的Alarm任务，等Alarm任务到执行时间了，会自动唤醒App。

缺点：

• 在App被杀和拉起之间，会显示系统Launcher桌面，体验不好。


• 在高版本不适用

方法2 直接启动Activity

private void restartApp(){

    Intent intent = new Intent(this, MainActivity.class);

    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

    startActivity(intent);

    Process.killProcess(Process.myPid());

    System.exit(0);

}

缺点：

• MainActivity必须是Standard模式

方法3 ProcessPhoenix

JakeWharton大神开源了一个叫ProcessPhoenix的库，这个库可以实现无缝重启app。

实现原理其实很简单，我们先讲怎么使用，然后再来分析源码。

使用方法

首先引入ProcessPhoenix库，这个库不需要初始化，可以直接使用。

implementation 'com.jakewharton:process-phoenix:2.1.2'

使用1：如果想重启app后进入首页：

ProcessPhoenix.triggerRebirth(context);

使用2：如果想重启app后进入特定的页面，则需要构造具体页面的intent，当做参数传入：

Intent nextIntent = //...

ProcessPhoenix.triggerRebirth(context, nextIntent);

有一点需要特别注意。

• 我们通常会在Application的onCreate方法中做一系列初始化的操作。


• 如果使用Phoenix库，需要在onCreate方法中判断，如果当前进程是Phoenix进程，则直接return，跳过初始化的操作。

if (ProcessPhoenix.isPhoenixProcess(this)) {

  return;

}

源码

ProcessPhoenix的原理：

• 当调用triggerRebirth方法的时候，会启动一个透明的Activity，这个Activity运行在:phoenix进程


• Activity启动后，杀掉主进程，然后用:phoenix进程拉起主进程的Activity


• 关闭当前Activity，杀掉:phoenix进程

先来看看Manifest中Activity的注册代码：

 <activity

        android:name=".ProcessPhoenix"

        android:theme="@android:style/Theme.Translucent.NoTitleBar"

        android:process=":phoenix"

        android:exported="false"

        />

可以看到这个Activity确实是在:phoenix进程启动的，且是Translucent透明的。

整个ProcessPhoenix的代码只有不到120行，非常简单。我们来看下triggerRebirth做了什么。

  public static void triggerRebirth(Context context) {

    triggerRebirth(context, getRestartIntent(context));

  }

不带intent的triggerRebirth，最后也会调用到带intent的triggerRebirth方法。

getRestartIntent会获取主进程的Launch Activity。

  private static Intent getRestartIntent(Context context) {

    String packageName = context.getPackageName();

    Intent defaultIntent = context.getPackageManager().getLaunchIntentForPackage(packageName);

    if (defaultIntent != null) {

      return defaultIntent;

    }

  }

所以要调用不带intent的triggerRebirth，必须在当前App的manifest里，指定Launch Activity，否则会抛出异常。

接着来看看真正的triggerRebirth方法：

  public static void triggerRebirth(Context context, Intent... nextIntents) {

    if (nextIntents.length < 1) {

      throw new IllegalArgumentException("intents cannot be empty");

    }

    // 第一个activity添加new_task标记，重新开启一个新的stack

    nextIntents[0].addFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK);



    Intent intent = new Intent(context, ProcessPhoenix.class);

    // 这里是为了防止传入的context非Activity

    intent.addFlags(FLAG_ACTIVITY_NEW_TASK); // In case we are called with non-Activity context.

    // 将待启动的intent作为参数，intent是parcelable的

    intent.putParcelableArrayListExtra(KEY_RESTART_INTENTS, new ArrayList<>(Arrays.asList(nextIntents)));

    // 将主进程的pid作为参数

    intent.putExtra(KEY_MAIN_PROCESS_PID, Process.myPid());

    // 启动ProcessPhoenix Activity

    context.startActivity(intent);

  }

triggerRebirth方法，主要的功能是启动ProcessPhoenix Activity，相当于启动了:phoenix进程。同时，会将nextIntents和主进程的pid作为参数，传给新启动的ProcessPhoenix Activity。

下面我们再来看看，ProcessPhoenix Activity的onCreate方法，看看新进程启动后做了什么。

  @Override protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    // 首先杀死主进程

    Process.killProcess(getIntent().getIntExtra(KEY_MAIN_PROCESS_PID, -1)); // Kill original main process



    ArrayList<Intent> intents = getIntent().getParcelableArrayListExtra(KEY_RESTART_INTENTS);

    // 再启动主进程的intents

    startActivities(intents.toArray(new Intent[intents.size()]));

    // 关闭当前Activity，杀掉当前进程

    finish();

    Runtime.getRuntime().exit(0); // Kill kill kill!

  }

:phoenix进程主要做了以下事情：

• 杀死主进程


• 用传入的Intent启动主进程的Activity（也可以是Service）


• 关闭phoenix Activity，杀掉phoenix进程

总结

如果App有自动重启的需求，比较推荐使用ProcessPhoenix的方法。

原理其实非常简单：

• 启动一个新的进程


• 杀掉主进程


• 用新的进程，重新拉起主进程


• 杀掉新的进程

我们可以直接在工程里引入ProcessPhoenix开源库，也可以自己用代码实现这样的机

errors

错误处理在编程中是不可避免的一部分，在程序开发过程中，不可必要的会出现各种的错误，是人为也可能是失误，任何不可预料的可能都会发生

为了更好的保证程序的健壮性和稳定性

我们必须要对错误处理有更好的认识

最近迷上了golang的错误处理哲学，希望由浅入深的总结一下自己的思考和看得见的思考

👀 用 error 表示可能出现的错误，用throw强制抛出错误

通常情况下 错误处理的方式无非不过两种

• 泛处理


• 精处理

其实都很好理解

// 伪代码



try {

const file = await readFile('../file')



const content =  filterContent(file)



} catch (e) {

  alert('xxxx',e.msg)

}

泛处理指的是对所有可能的错误都使用相同的处理方式，比如在代码中使用相同统一的错误提示信息

这种方式适用于一些简单的，不太可能发生的错误，不如文件不存在，网络连接超时等。

对于更加复杂的错误，应该使用精处理，即根据具体情况对不同类型的错误进行特定的处理

const [readErr,readFile] = await readFile('../file')



if (readErr) {

    // 处理读取错误

    return 

}



const [filterErr,filterContent] =  filterContent(readFile)



if (filterErr) {

    // 处理过滤错误

    return

}

精处理可以让我们把控计划的每一步，问题也很显然暴露了出来，过于麻烦

在实际开发当中，我们需要根据实际情况选择适当的方式进行错误处理。

由于本人是精处理分子，基于此开发了一个js版本的errors包

如何定义一个错误

import { Errors } from '@memo28/utils'



Errors.News('err')

如何给一个错误分类

import { Errors } from '@memo28/utils'



Errors.News('err', { classify: 1 })

如何判断两个错误是相同类型

import { Errors } from '@memo28/utils'



Errors.As(Errors.News('err', { classify: 1 }),

Errors.News('err2', { classify: 1 })) // true



Errors.As(Errors.News('err', { classify: 1 }),

Errors.News('err2', { classify: 2 })) // false

一个错误包含了哪些信息？

Errors.New('as').info() // { msg: 'as' , classify: undefined }



Errors.New('as').trace() // 打印调用栈



Errors.New('as').unWrap() // 'as'

最佳实践

import { AnomalousChain, panicProcessing } from '@memo28/utils'



class A extends AnomalousChain {

  // 定义错误处理函数,

  // 当每次执行的被 panicProcessing 装饰器包装过的函数都会检查 是否存在 this.errors 是否为 ErrorsNewResult 类型

  // 如果为 ErrorsNewResult 类型则 调用 panicProcessing的onError回调 和 skip函数

  skip(errors: ErrorsNewResult | null): this {

    console.log(errors?.info().msg)

    return this

  }



  @panicProcessing()

  addOne(): this {

    console.log('run one')

    super.setErrors(Errors.New('run one errors'))

    return this

  }



  @panicProcessing({

    // 在 skip 前执行

    onError(error) {

      console.log(error.unWrap())

    },

    // onRecover 从错误中恢复, 当返回的是true时 继续执行addTwo内逻辑，反之

    // onRecover(erros) {

    //   return true

    // },

  })

  addTwo(): this {

    console.log('run two')

    return this

  }

}

new A().addOne().addTwo()







// output

run one

run one errors // in onError

run one errors // in skip fn



复制代码
作者：我开心比苦恼多
来源：juejin.cn/post/7207707775774031930
>

先抛几个数据：

当下，每天有超过 2 亿的人在疯狂地抛出各式各样的问题请求 ChatGPT 回复

如果要完成这 2 亿+ 的咨询量，初始投入需要 3 万+ 块英伟达 A100 GPU 来计算

而 A100 是当下这个星球拥有最强 AI 算力的芯片，买一块至少要 7W+ RMB💴

意思就是：光计算这些有意义/无意义的问题，就要花费：21 亿+ RMB 💴

这还不算电费/维护费等，众所周知，这种庞大计算类似矿机，很费电

一块 A100，功率 400W，30000 块 A100 ，就是 12_000_000 W，是 12 MW（12 个 100 万瓦）

目前，“GPT们”就像是井喷一样出现了各类产品，先不管算的结果怎么样，大家先支棱起来、先算起来

有预测：十年后，“GPT们” 一天所需算力的生产功率相当于半个核电站产生的功率，这是离谱且夸张的！全球算力几乎快要无法满足“GPT们”了

所以，以 ChatGPTPlus（每月20刀） 为代表的 “GPT们” 很贵，因为它本来算力消费就很贵，“用 GPT 编程比招一个普通程序员更贵”的段子并非玩笑。

所以，为什么算力如此重要？为什么微软要和韩国SK集团布局自建核电站？为什么咱们要强调西数东算、云计算等等？从这里也能窥见一斑。

不夸张的说，在未来，国力强弱一方面将通过算力强弱来体现。

_{2016年6月的不同国家之间的超级计算机500强的分布}

_{超级计算机模拟风洞实验}

小思考：在未来，算力的瓶颈将如何突破？

—— 目前芯片仍处在传统冯·诺伊曼架构之下，存储和计算区域是分离的，搬运数据“从存储到计算”花费巨大的功耗，如果能实现“存算一体”（就像大脑一样）将提升算力进入新的量级。

所以“存算一体”可能是个方向~

推荐阅读：

# 计算型存储/存算一体如何实现？ - bonnie的回答

# 5分钟新知关注芯片算力｜存算一体为什么是AI时代主流计算架构？

字号与体验

肉眼到物体之间的距离，物体的高度以及这个三角形的角度，构成了一个三角函数的关系。

h=2d*tan(a/2)

而公式中的 h 的值和我们要解决的核心问题『主字号』有着很大的关系。

关于这个 a 的角度，有机构和团队做过研究，当大于 0.3 度时的阅读效率是最好的。

同时我们在操作电脑时，一般来说眼睛距离电脑屏幕的平均值大概会在 50 厘米左右。

然而，公式中的距离和高度的单位都是厘米，字体的单位是 pixel。

因此我们还需要将二者之间做一轮转换，完成转换所需的两个数值分别是 2.54（cm 到 inch）和 PPI（inch 到 pixel）。           

*PPI（Pixels Per Inch）：像素密度，所表示的是每英寸所拥有的像素数量。

公式表达为_ppi_=√(x2+y2)/z(x:长度像素数;y:宽度像素数;z:屏幕大小)  

我们假定 PPI 为 120。通过计算便可以得出在显示器的 PPI 为 120 的情况下，理论上大于 12px 的字体能够满足用户的最佳阅读效率。基于这样的思路，确定主流 PPI 的范围，就很容易锁定主字体的大小了。

根据网络上的数据来源，我们发现只有大约 37.6% 的显示器 PPI 是小于 120 的，而 PPI 在 120－140 的显示器的占比大约为 40%。换句话说 12px 的字体只能满足 37.6% 用户的阅读体验，但如果我们将字体放大到 14px，就可以保证大约 77% 的显示器用户处于比较好的阅读体验。

场景

在大多数前端应用中都会有自己的用户模块，对于前端应用中的用户模块来说，需要从多个方面功能考虑，以掘金为例，可能需要下面这些功能：

1. 多种登录方式，账号密码，手机验证码，第三方登录等


2. 展示类信息，用户头像、用户名、个人介绍等


3. 用户权限控制，可能需要附带角色信息等


4. 发起请求可能还需要带上token等

接下来我们来一步步实现一个简单的用户模块

需求分析

用户模型

针对这些需求我们可以列出一个用户模型，包括下面这些参数

展示信息：

• username 用户名


• avatar 头像


• introduction 个人介绍

角色信息：

• role

鉴权：

• 
  

  token

  
  

这个user模型对于前端应用来说应该是全局唯一的，我们这里可以用singleton，标注为全局单例

import { singleton } from '@clean-js/presenter';



@singleton()

export class User {

  username = '';

  avatar = '';

  introduction = '';



  role = 'member';

  token = '';



  init(data: Partial<Omit<User, 'init'>>) {

    Object.assign(this, data);

  }

}

用户服务

接着可以针对我们的用户场景来构建用户服务类。

如下面这个UserService：

• 注入了全局单例的User


• loginWithMobile 提供了手机号验证码登录方法，这里我们用一个mock代码来模拟请求登录


• updateUserInfo 用来获取用户信息，如头像，用户名之类的。从后端拉取信息之后我们会更新单例User

import { injectable } from '@clean-js/presenter';

import { User } from '../entity/user';





@injectable()

export class UserService {

  constructor(private user: User) {}





  /**

   * 手机号验证码登录

   */

  loginWithMobile(mobile: string, code: string) {

    // mock 请求接口登录

    return new Promise((resolve) => {

      setTimeout(() => {

        this.user.init({

          token: 'abcdefg',

        });





        resolve(true);

      }, 1000);

    });

  }





  updateUserInfo() {

    // mock 请求接口登录

    return new Promise<User>((resolve) => {

      setTimeout(() => {

        this.user.init({

          avatar:

            'https://p3-passport.byteimg.com/img/user-avatar/2245576e2112372252f4fbd62c7c9014~180x180.awebp',

          introduction: '欢乐堡什么都有，唯独没有欢乐',

          username: '鱼露',

          role: 'member',

        });





        resolve(this.user);

      }, 1000);

    });

  }

}

界面状态

我们以登录界面和个人中心页面为例

登录界面

在登录界面需要这些页面状态和方法

View State:

• loading: boolean; 页面loading


• mobile: string; 输入手机号


• code: string; 输入验证码

methods：

• showLoading


• hideLoading


• login

import { history } from 'umi';

import { UserService } from '@/module/user/service/user';

import { LockOutlined, UserOutlined } from '@ant-design/icons';

import { injectable, Presenter } from '@clean-js/presenter';

import { usePresenter } from '@clean-js/react-presenter';

import { Button, Form, Input, message, Space } from 'antd';



interface IViewState {

  loading: boolean;

  mobile: string;

  code: string;

}

@injectable()

class PagePresenter extends Presenter<IViewState> {

  constructor(private userService: UserService) {

    super();

    this.state = {

      loading: false,

      mobile: '',

      code: '',

    };

  }



  _loadingCount = 0;



  showLoading() {

    if (this._loadingCount === 0) {

      this.setState((s) => {

        s.loading = true;

      });

    }

    this._loadingCount += 1;

  }



  hideLoading() {

    this._loadingCount -= 1;

    if (this._loadingCount === 0) {

      this.setState((s) => {

        s.loading = false;

      });

    }

  }



  login = () => {

    const { mobile, code } = this.state;

    this.showLoading();

    return this.userService

      .loginWithMobile(mobile, code)

      .then((res) => {

        if (res) {

          message.success('登录成功');

        }

      })

      .finally(() => {

        this.hideLoading();

      });

  };

}



export default function LoginPage() {

  const { p } = usePresenter(PagePresenter);



  return (

    <div>

      <Form

        name="normal_login"

        initialValues={{ email: 'admin@admin.com', password: 'admin' }}

        onFinish={() => {

          console.log(p, '==p');

          p.login().then(() => {

            setTimeout(() => {

              history.push('/profile');

            }, 1000);

          });

        }}

      >

        <Form.Item

          name="email"

          rules={[{ required: true, message: 'Please input your email!' }]}

        >

          <Input

            prefix={<UserOutlined className="site-form-item-icon" />}

            placeholder="email"

          />

        </Form.Item>

        <Form.Item

          name="password"

          rules={[{ required: true, message: 'Please input your Password!' }]}

        >

          <Input

            prefix={<LockOutlined className="site-form-item-icon" />}

            type="password"

            placeholder="Password"

          />

        </Form.Item>



        <Form.Item>

          <Space>

            <Button

              type="primary"

              htmlType="submit"

              className="login-form-button"

            >

              Log in

            </Button>

          </Space>

        </Form.Item>

      </Form>

    </div>

  );

}

如上代码所示，一个登录页面就完成了，接下来我们实现一下个人中心页面

个人中心

import { UserService } from '@/module/user/service/user';

import { injectable, Presenter } from '@clean-js/presenter';

import { usePresenter } from '@clean-js/react-presenter';

import { Image, Spin } from 'antd';

import { useEffect } from 'react';



interface IViewState {

  loading: boolean;

  username: string;

  avatar: string;

  introduction: string;

}



@injectable()

class PagePresenter extends Presenter<IViewState> {

  constructor(private userS: UserService) {

    super();

    this.state = {

      loading: false,

      username: '',

      avatar: '',

      introduction: '',

    };

  }



  _loadingCount = 0;



  showLoading() {

    if (this._loadingCount === 0) {

      this.setState((s) => {

        s.loading = true;

      });

    }

    this._loadingCount += 1;

  }



  hideLoading() {

    this._loadingCount -= 1;

    if (this._loadingCount === 0) {

      this.setState((s) => {

        s.loading = false;

      });

    }

  }



  /**

   * 拉取用户信息

   */

  getUserInfo() {

    this.showLoading();

    this.userS

      .updateUserInfo()

      .then((u) => {

        this.setState((s) => {

          s.avatar = u.avatar;

          s.username = u.username;

          s.introduction = u.introduction;

        });

      })

      .finally(() => {

        this.hideLoading();

      });

  }

}

const ProfilePage = () => {

  const { p } = usePresenter(PagePresenter);



  useEffect(() => {

    p.getUserInfo();

  }, []);



  return (

    <Spin spinning={p.state.loading}>

      <p>

        avatar: <Image src={p.state.avatar} width={100} alt="avatar"></Image>

      </p>

      <p>username: {p.state.username}</p>

      <p>introduction: {p.state.introduction}</p>

    </Spin>

  );

};



export default ProfilePage;

在这个ProfilePage中，我们初始化时会执行p.getUserInfo();

期间会切换loading的状态，并映射到页面的Spin组件中，执行完成后，更新页面的用户信息，用于展示

总结

至此，一个简单的用户模块就实现啦，整个用户模块以及页面的依赖关系可以查看下面这个UML图，

状态库仓库

仓库

各位大佬，记得一键三连，给个star，谢谢

问题背景

最近跟群友讨论一个技术问题：

一个应用开启了多进程，最终到底会创建几个application对象，执行几次onCreate()方法？

有的群友根据自己的想法给出了猜想

甚至有的群友直接咨询起了ChatGPT

但至始至终都没有一个最终的结论。于是乎，为了弄清这个问题，我决定先写个demo测试得出结论，然后从源码着手分析原因

Demo验证

首先创建了一个app项目，开启多进程

<?xml version="1.0" encoding="utf-8"?>

<manifest

    xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools">



    <application

        android:name=".DemoApplication"

        android:allowBackup="true"

        android:dataExtractionRules="@xml/data_extraction_rules"

        android:fullBackupContent="@xml/backup_rules"

        android:icon="@mipmap/ic_launcher"

        android:label="@string/app_name"

        android:roundIcon="@mipmap/ic_launcher_round"

        android:supportsRtl="true"

        android:theme="@style/Theme.Demo0307"

        tools:targetApi="31">

        <!--android:process 开启多进程并设置进程名-->

        <activity

            android:name=".MainActivity"

            android:exported="true"

            android:process=":remote">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />



                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>



        </activity>

    </application>



</manifest>

然后在DemoApplication的onCreate()方法打印application对象的地址，当前进程名称

public class DemoApplication extends Application {

    private static final String TAG = "jasonwan";



    @Override

    public void onCreate() {

        super.onCreate();

        Log.d(TAG, "Demo application onCreate: " + this + ", processName=" + getProcessName(this));

    }



    private String getProcessName(Application app) {

        int myPid = Process.myPid();

        ActivityManager am = (ActivityManager) app.getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);

        List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = am.getRunningAppProcesses();

        for (ActivityManager.RunningAppProcessInfo runningAppProcess : runningAppProcesses) {

            if (runningAppProcess.pid == myPid) {

                return runningAppProcess.processName;

            }

        }

        return "null";

    }

}

运行，得到的日志如下

2023-03-07 11:15:27.785 19563-19563/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote

查看当前应用所有进程

说明此时app只有一个进程，且只有一个application对象，对象地址为@fb06c2d

现在我们将进程增加到多个，看看情况如何

<?xml version="1.0" encoding="utf-8"?>

<manifest

    xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools">



    <application

        android:name=".DemoApplication"

        android:allowBackup="true"

        android:dataExtractionRules="@xml/data_extraction_rules"

        android:fullBackupContent="@xml/backup_rules"

        android:icon="@mipmap/ic_launcher"

        android:label="@string/app_name"

        android:roundIcon="@mipmap/ic_launcher_round"

        android:supportsRtl="true"

        android:theme="@style/Theme.Demo0307"

        tools:targetApi="31">

        <!--android:process 开启多进程并设置进程名-->

        <activity

            android:name=".MainActivity"

            android:exported="true"

            android:process=":remote">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />



                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>



        </activity>

        <activity

            android:name=".TwoActivity"

            android:process=":remote2" />

        <activity

            android:name=".ThreeActivity"

            android:process=":remote3" />

        <activity

            android:name=".FourActivity"

            android:process=":remote4" />

        <activity

            android:name=".FiveActivity"

            android:process=":remote5" />

    </application>



</manifest>

逻辑是点击MainActivity启动TwoActivity，点击TwoActivity启动ThreeActivity，以此类推。最后我们运行，启动所有Activity得到的日志如下

2023-03-07 11:25:35.433 19955-19955/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote

2023-03-07 11:25:43.795 20001-20001/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote2

2023-03-07 11:25:45.136 20046-20046/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote3

2023-03-07 11:25:45.993 20107-20107/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote4

2023-03-07 11:25:46.541 20148-20148/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote5

查看当前应用所有进程

此时app有5个进程，但application对象地址均为@fb06c2d，地址相同意味着它们是同一个对象。

那是不是就可以得出结论，无论启动多少个进程都只会创建一个application对象呢？并不能妄下此定论，我们将MainActivity的process属性去掉再运行，得到的日志如下

2023-03-07 11:32:10.156 20318-20318/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@5d49e29, processName=com.jason.demo0307

2023-03-07 11:32:15.143 20375-20375/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote2

2023-03-07 11:32:16.477 20417-20417/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote3

2023-03-07 11:32:17.582 20463-20463/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote4

2023-03-07 11:32:18.882 20506-20506/com.jason.demo0307 D/jasonwan: Demo application onCreate: com.jason.demo0307.DemoApplication@fb06c2d, processName=com.jason.demo0307:remote5

查看当前应用所有进程

此时app有5个进程，但有2个application对象，对象地址为@5d49e29和@fb06c2d，且子进程的application对象都相同。

上述所有进程的父进程ID为678，而此进程正是zygote进程

根据上面的测试结果我们目前能得出的结论：

• 结论1：单进程只创建一个Application对象，执行一次onCreate()方法；


• 结论2：多进程至少创建2个Application对象，执行多次onCreate()方法，几个进程就执行几次；

结论2为什么说至少创建2个，因为我在集成了JPush的商业项目中测试发现，JPush创建的进程跟我自己创建的进程，Application地址是不同的。

这里三个进程，分别创建了三个Application对象，对象地址分别是@f31ba9d，@2c586f3，@fb06c2d

源码分析

这里需要先了解App的启动流程，具体可以参考《App启动流程》

Application的创建位于frameworks/base/core/java/android/app/ActivityThread.java的handleBindApplication()方法中

	@UnsupportedAppUsage

    private void handleBindApplication(AppBindData data) {

        long st_bindApp = SystemClock.uptimeMillis();

        //省略部分代码



        // Note when this process has started.

        //设置进程启动时间

        Process.setStartTimes(SystemClock.elapsedRealtime(), SystemClock.uptimeMillis());



        //省略部分代码



        // send up app name; do this *before* waiting for debugger

        //设置进程名称

        Process.setArgV0(data.processName);

        //省略部分代码

        

        // Allow disk access during application and provider setup. This could

        // block processing ordered broadcasts, but later processing would

        // probably end up doing the same disk access.

        Application app;

        final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();

        final StrictMode.ThreadPolicy writesAllowedPolicy = StrictMode.getThreadPolicy();

        try {

            // If the app is being launched for full backup or restore, bring it up in

            // a restricted environment with the base application class.

            //此处开始创建application对象，注意参数2为null

            app = data.info.makeApplication(data.restrictedBackupMode, null);



            //省略部分代码

            try {

                if ("com.jason.demo0307".equals(app.getPackageName())){

                    Log.d("jasonwan", "execute app onCreate(), app=:"+app+", processName="+getProcessName(app)+", pid="+Process.myPid());

                }

                //执行application的onCreate方法()

                mInstrumentation.callApplicationOnCreate(app);

            } catch (Exception e) {

                if (!mInstrumentation.onException(app, e)) {

                    throw new RuntimeException(

                      "Unable to create application " + app.getClass().getName()

                      + ": " + e.toString(), e);

                }

            }

        } finally {

            // If the app targets < O-MR1, or doesn't change the thread policy

            // during startup, clobber the policy to maintain behavior of b/36951662

            if (data.appInfo.targetSdkVersion < Build.VERSION_CODES.O_MR1

                    || StrictMode.getThreadPolicy().equals(writesAllowedPolicy)) {

                StrictMode.setThreadPolicy(savedPolicy);

            }

        }

        //省略部分代码

    }

实际创建过程在frameworks/base/core/java/android/app/LoadedApk.java中的makeApplication()方法中，LoadedApk顾名思义就是加载好的Apk文件，里面包含Apk所有信息，像包名、Application对象，app所在的目录等，这里直接看application的创建过程

	@UnsupportedAppUsage

    public Application makeApplication(boolean forceDefaultAppClass,

            Instrumentation instrumentation) {

        if ("com.jason.demo0307".equals(mApplicationInfo.packageName)) {

            Log.d("jasonwan", "makeApplication: mApplication="+mApplication+", pid="+Process.myPid());

        }

        //如果已经创建过了就不再创建

        if (mApplication != null) {

            return mApplication;

        }



        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "makeApplication");



        Application app = null;



        String appClass = mApplicationInfo.className;

        if (forceDefaultAppClass || (appClass == null)) {

            appClass = "android.app.Application";

        }



        try {

            java.lang.ClassLoader cl = getClassLoader();

            if (!mPackageName.equals("android")) {

                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,

                        "initializeJavaContextClassLoader");

                initializeJavaContextClassLoader();

                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

            }

            ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);

            //反射创建application对象

            app = mActivityThread.mInstrumentation.newApplication(

                    cl, appClass, appContext);

            if ("com.jason.demo0307.DemoApplication".equals(appClass)){

                Log.d("jasonwan", "create application, app="+app+", processName="+mActivityThread.getProcessName()+", pid="+Process.myPid());

            }

            appContext.setOuterContext(app);

        } catch (Exception e) {

            Log.d("jasonwan", "fail to create application, "+e.getMessage());

            if (!mActivityThread.mInstrumentation.onException(app, e)) {

                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

                throw new RuntimeException(

                    "Unable to instantiate application " + appClass

                    + ": " + e.toString(), e);

            }

        }

        mActivityThread.mAllApplications.add(app);

        mApplication = app;



        if (instrumentation != null) {

            try {

                //第一次启动创建时，instrumentation为null，不会执行onCreate()方法

                instrumentation.callApplicationOnCreate(app);

            } catch (Exception e) {

                if (!instrumentation.onException(app, e)) {

                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

                    throw new RuntimeException(

                        "Unable to create application " + app.getClass().getName()

                        + ": " + e.toString(), e);

                }

            }

        }



        // 省略部分代码

        return app;

    }

为了看清application到底被创建了几次，我在关键地方埋下了log，TAG为jasonwan的log是我自己加的，编译验证，得到如下log

启动app，进入MainActivity

03-08 17:20:29.965  4069  4069 D jasonwan: makeApplication: mApplication=null, pid=4069

//创建application对象，地址为@c2f8311，当前进程id为4069

03-08 17:20:29.967  4069  4069 D jasonwan: create application, app=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307, pid=4069

03-08 17:20:29.988  4069  4069 D jasonwan: execute app onCreate(), app=:com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307, pid=4069

03-08 17:20:29.989  4069  4069 D jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307, pid=4069

03-08 17:20:36.614  4069  4069 D jasonwan: makeApplication: mApplication=com.jason.demo0307.DemoApplication@c2f8311, pid=4069



点击MainActivity，跳转到TwoActivity

03-08 17:20:39.686  4116  4116 D jasonwan: makeApplication: mApplication=null, pid=4116

//创建application对象，地址为@c2f8311，当前进程id为4116

03-08 17:20:39.687  4116  4116 D jasonwan: create application, app=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote2, pid=4116

03-08 17:20:39.688  4116  4116 D jasonwan: execute app onCreate(), app=:com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote2, pid=4116

03-08 17:20:39.688  4116  4116 D jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote2, pid=4116

03-08 17:20:39.733  4116  4116 D jasonwan: makeApplication: mApplication=com.jason.demo0307.DemoApplication@c2f8311, pid=4116



点击TwoActivity，跳转到ThreeActivity

03-08 17:20:41.473  4147  4147 D jasonwan: makeApplication: mApplication=null, pid=4147

//创建application对象，地址为@c2f8311，当前进程id为4147

03-08 17:20:41.475  4147  4147 D jasonwan: create application, app=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote3, pid=4147

03-08 17:20:41.475  4147  4147 D jasonwan: execute app onCreate(), app=:com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote3, pid=4147

03-08 17:20:41.476  4147  4147 D jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote3, pid=4147

03-08 17:20:41.519  4147  4147 D jasonwan: makeApplication: mApplication=com.jason.demo0307.DemoApplication@c2f8311, pid=4147



点击ThreeActivity，跳转到FourActivity

03-08 17:20:42.966  4174  4174 D jasonwan: makeApplication: mApplication=null, pid=4174

//创建application对象，地址为@c2f8311，当前进程id为4174

03-08 17:20:42.968  4174  4174 D jasonwan: create application, app=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote4, pid=4174

03-08 17:20:42.969  4174  4174 D jasonwan: execute app onCreate(), app=:com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote4, pid=4174

03-08 17:20:42.969  4174  4174 D jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote4, pid=4174

03-08 17:20:43.015  4174  4174 D jasonwan: makeApplication: mApplication=com.jason.demo0307.DemoApplication@c2f8311, pid=4174



点击FourActivity，跳转到FiveActivity

03-08 17:20:44.426  4202  4202 D jasonwan: makeApplication: mApplication=null, pid=4202

//创建application对象，地址为@c2f8311，当前进程id为4202

03-08 17:20:44.428  4202  4202 D jasonwan: create application, app=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote5, pid=4202

03-08 17:20:44.429  4202  4202 D jasonwan: execute app onCreate(), app=:com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote5, pid=4202

03-08 17:20:44.430  4202  4202 D jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@c2f8311, processName=com.jason.demo0307:remote5, pid=4202

03-08 17:20:44.473  4202  4202 D jasonwan: makeApplication: mApplication=com.jason.demo0307.DemoApplication@c2f8311, pid=4202

结果很震惊，我们在5个进程中创建的application对象，地址均为@c2f8311，也就是至始至终创建的都是同一个Application对象，那么上面的结论2显然并不成立，只是测试的偶然性导致的。

可真的是这样子的吗，这也太颠覆我的三观了，为此我跟群友讨论了这个问题：

不同进程中的多个对象，内存地址相同，是否代表这些对象都是同一个对象？

群友的想法是，java中获取的都是虚拟内存地址，虚拟内存地址相同，不代表是同一个对象，必须物理内存地址相同，才表示是同一块内存空间，也就意味着是同一个对象，物理内存地址和虚拟内存地址存在一个映射关系，同时给出了java中获取物理内存地址的方法Android获取对象地址，主要是利用Unsafe这个类来操作，这个类有一个作用就是直接访问系统内存资源，具体描述见Java中的魔法类-Unsafe，因为这种操作是不安全的，所以被标为了私有，但我们可以通过反射去调用此API， 然后我又去请教了部门搞寄存器的大佬，大佬肯定了群友的想法，于是我添加代码，尝试获取对象的物理内存地址，看看是否相同

public class DemoApplication extends Application {

    public static final String TAG = "jasonwan";



    @Override

    public void onCreate() {

        super.onCreate();

        Log.d(TAG, "DemoApplication=" + this + ", address=" + addressOf(this) + ", pid=" + Process.myPid());

    }



    //获取对象的真实物理地址

    public static long addressOf(Object o) {

        Object[] array = new Object[]{o};

        long objectAddress = -1;

        try {

            Class cls = Class.forName("sun.misc.Unsafe");

            Field field = cls.getDeclaredField("theUnsafe");

            field.setAccessible(true);

            Object unsafe = field.get(null);

            Class unsafeCls = unsafe.getClass();

            Method arrayBaseOffset = unsafeCls.getMethod("arrayBaseOffset", Object.class.getClass());

            int baseOffset = (int) arrayBaseOffset.invoke(unsafe, Object[].class);

            Method size = unsafeCls.getMethod("addressSize");

            int addressSize = (int) size.invoke(unsafe);

            switch (addressSize) {

                case 4:

                    Method getInt = unsafeCls.getMethod("getInt", Object.class, long.class);

                    objectAddress = (int) getInt.invoke(unsafe, array, baseOffset);

                    break;

                case 8:

                    Method getLong = unsafeCls.getMethod("getLong", Object.class, long.class);

                    objectAddress = (long) getLong.invoke(unsafe, array, baseOffset);

                    break;

                default:

                    throw new Error("unsupported address size: " + addressSize);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return objectAddress;

    }

}

运行后得到如下日志

2023-03-10 11:01:54.043 6535-6535/com.jason.demo0307 D/jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@930d275, address=8050489105119022792, pid=6535

2023-03-10 11:02:22.610 6579-6579/com.jason.demo0307 D/jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@331b3b9, address=8050489105119027136, pid=6579

2023-03-10 11:02:36.369 6617-6617/com.jason.demo0307 D/jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@331b3b9, address=8050489105119029912, pid=6617

2023-03-10 11:02:39.244 6654-6654/com.jason.demo0307 D/jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@331b3b9, address=8050489105119032760, pid=6654

2023-03-10 11:02:40.841 6692-6692/com.jason.demo0307 D/jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@331b3b9, address=8050489105119036016, pid=6692

2023-03-10 11:02:52.429 6729-6729/com.jason.demo0307 D/jasonwan: DemoApplication=com.jason.demo0307.DemoApplication@331b3b9, address=8050489105119038720, pid=6729

可以看到，虽然Application的虚拟内存地址相同，都是331b3b9，但它们的真实物理地址却不同，至此，我们可以得出最终结论：

• 单进程，创建1个application对象，执行一次onCreate()方法


• 多进程(N)，创建N个application对象，执行N次onCreate()方法

【回顾】

十年，目睹了时代的改变，也见证了技术的迭代。

【2011】大学毕业前的实习

这一年，大学即将毕业毕业，寒假回到了家乡的小县城，歪打正着的找了一份家乡县级市ZF的实习工作（合同工）。

• 技术：Ps Html Css


• 内容：内网新闻专题


• 薪资：1500


• 房价：3000/平

【2012】大学毕业了

这一年，大学毕业了，毕业那天喝了很多，并豪情壮志的和室友预定了四个五年计划。（一五：年薪10万。二五，年薪20万，三五，年薪30万，四五，财富自由。）

于是我放弃了ZF的安稳，只身来到了当地的十八线小城市，为了安身立命，于是随便找了一家只有2人的公司做网站~

• 职位：美工


• 技术：Ps Html Css Asp


• 内容：企业网站


• 薪资：1000


• 房租：600


• 房价：3500/平

这段时间，由于工资过低，每天只吃1-2顿饭，而且每天熬夜学习，体重从大学期间的100Kg降到了65Kg。

终于，在2012年的下半年找到了自己的第一份正式工作--所在城市日报集团。

• 职位：美工


• 技术：Ps Html Css JQ PHP


• 门户网站、专题、企业网站


• 薪资：3500


• 房租：0（包吃住）


• 房价：3500/平

【2014】开始学H5+C3

由于不知道多少线的小城市，技术需求极低，大部分工作内容还要考虑IE6的兼容性。技术部老大跟我说H5和C3咱们一时半会是用不到的。但我还是学了，我觉得早晚会用到。

• 职位：美工


• 技术：Ps Html Css JQ PHP


• 门户网站、专题、企业网站


• 薪资：3800


• 房租：0（包吃住）


• 房价：3500/平

【2015】辞职-新工作-公司解散-新工作

公司来了新领导，开始大刀阔斧的改革，并要求技术部承担经营任务，技术部老大一气之下带着我和另外一个程序W 离职了，大家决定自己干！

老大带我们组个个外包团队，包了一个公司的H5封装APP的活，签了3年的外包合同。我负责H5页面，W负责程序，老大负责服务器。我们仨找了个孵化器开始干了起来。

• 职位：美工？前端？


• 技术：Ps Html5 Css3 JQ


• H5封装APP


• 薪资：7000


• 房租：500


• 房价：5500/平

三个月后甲方撤资了~~ 突如其来的大家没了收入。老大还在努力的找新单子，我们也发现这不是长久之计，于是边接小单子边找新的出路。

新工作来的很意外，之前报社的老领导去了临市的大众网记者站当副站长，又被调回我们城市成立新的记者站。于是老领导找到了我，他们需要一个全栈员工。老领导于我也算是有知遇之恩，所以我决定去帮帮她。虽然给了我主任级别的待遇，但是工资依然不高。

• 职位：全栈


• 技术：Ps Html5 Css3 JQ 内部cms


• 门户网站、专题、企业网站 微信H5


• 薪资：4000


• 房租：500


• 房价：5500/平

【2016】 微信小程序来了

这一年，微信小程序的风吹进了我们这座小城市，开始有人问我会不会做。于是开始学习，并成功为一个经典做了一个卖票小程序，赚了3000.

• 职位：全栈


• 技术：Ps Html5 Css3 JQ 内部cms


• 门户网站、专题、企业网站 微信H5


• 薪资：4500


• 房租：500


• 房价：6500/平

【2018】结婚-辞职-新工作

这一年，和相恋5年的女朋友结婚了。忽然之间有了责任的压力，看看工资卡的工资，现在的工作显然是不行了，于是我决定辞职。

当我决定辞职之后我收到了两个橄榄枝，分别是老东家报社，和老同事W的。

老东家的一个同事已经升为主任，邀请我回去，工资开到了7500，在一个报社这样的单位我知道这是她的极限了。

W则是在我们三人组解散之后去了一家小公司，老板是个富二代，人也很好。现在业务增多想要叫我过去。

最终我选择了W的公司

• 职位：美工？前端？


• 技术：Ps Html5 Css3 JQ PHP


• 商城类网站


• 薪资：13000


• 房租：0（买房了，朋友的顶账房，没贷款欠朋友的，慢慢还。）


• 房价：8000/平

【2019】vue来了我却躺平了

这一年，老婆的公司开始使用VUE2了，老婆让我跟她一起学，我却沉迷游戏躺平了。

现在公司的环境很好，老板有钱人也很好。技术部的电脑都是i9-11代的处理器+2060的显卡，这哪里是公司简直是网吧。

公司也是经常几周甚至一个月没有新的业务，只要保证手里的几个网站正常运行就可以了，于是大家开始沉沦，每天上班也几乎都是在看电影和打游戏，还有免费的零食和饮料。

大家每天也都是在讨论哪个3A大作发售了，哪个电影上映了，很少能听到关于技术的讨论了。

• 职位：美工？前端？


• 技术：Ps Html5 Css3 JQ PHP


• 商城类网站


• 薪资：15000


• 房价：9000/平

【2020】疫情来了，小天使来了，危机也在慢慢靠近。

这一年，疫情开始蔓延，小宝宝也降生了。

公司还是一如既往，虽然我们知道业务在下滑，但是老板有钱，工资不降反升。

老婆打算辞掉工作专心把孩子带到3岁再工作。我考量了一下我的收入，觉得在这个不知道多少线的小城也算可以，就同意了。

• 职位：美工？前端？


• 技术：Ps Html5 Css3 JQ PHP


• 商城类网站


• 薪资：17000


• 房价：10000/平

【2021】终于开始学VUE和React

这一年，终于开始学习VUE和React，虽然公司依然没有使用新框架的打算，主要是因为后端不想写接口。想继续使用现在的程序。好像大家都躺平了，也可能是小城市的惬意。

• 职位：美工？前端？


• 技术：Ps Html5 Css3 JQ PHP


• 商城类网站


• 薪资：18000


• 房价：9000/平

【2022-上】听说大厂裁员，我们老板“毕业”了。

这一年，听说大厂都在裁员，小城市却依然风平浪静。大家日复一日的摸鱼。

某一天，噩耗传来，老板进去了，公司解散。WTF。

晴天霹雳，没想到我们还没毕业，老板却“毕业”了

• 职位：无


• 薪资：0


• 房价：9000/平

【2022-中】现实的社会和迟到的技术

2022精彩的一年，被狠狠的从舒适圈里踢了出来。一脸懵逼。

开始重新找工作却发现，自己的技术早已落伍，不得已又要从头学起。

无奈重新学了Vue2和Vue3，学了node.js，学了webpack，又学了ES6和TypeScript。

终于补完了前两年欠下的学习，却发现这个城市的前端工资普遍在6K-9K

落差感又一次让我一脸懵逼

【2022-下】焦虑和心虚

最终我进入了一家实体企业，HR看着我的简历对我十年的工作经验还算满意，我却很心虚。

总觉得自己这十年的工作经验水分很大。

看着比我年轻的同事熟练的使用着各种框架，而我却还在查着各种API。

我陷入了深深的自我怀疑，我是不是蹉跎了我的青春。

• 职位：前端


• 技术：Html5 Css3 Vue2


• 内部平台系统、微信小程序


• 薪资：9000


• 房价：9000/平

【总结】

小城市没有那么多的技术需求，也没有那么多的996，大家朝九晚五，周末双休过得很惬意。

刚毕业那会用着Table切图用着Asp做后台，大家只知道你是做网站的，公司招人也是招美工，要求设计、切图、程序都会一些。小城市就是要求你什么都会一点，但不用很精通，够用就行。

慢慢的随着技术的发展前端才被定义出来，但是很多公司招聘的时候写着需要使用Vue或者React，但事实上还是干这设计切图的活，前后端不分家。

小城市技术渗透的慢，但是依然在渗透，四年的惬意生活，让我慢慢的忘记自己最初的梦想，惊醒的时候却发现我已经掉队了。

【未来可期】

被踢出舒适圈，也被踢醒了

想想大学时期的四个五年计划一个也没实现，还剩最后一个，或许还能抢救一下，虽然很不切实际，但是总有个盼头。

重新规划自己的未来，躺也躺过了，现在想想躺平的日子也就那样。虽然自己已经30+但是还是可以继续搏一搏的。

重新定制一个三年计划吧

• 继续学习、阅读源码，做1-2个长期维护的项目。


• 研究下混合基金，适量投入。


• 看一些游戏开发相关的书，研究下Unreal引擎，争取做出一个游戏Demo。（游戏剧本已经写好了2个）。

前言

最近又到了一年一度的退税了，最近发了一个沸点，发现大家都是和我之前一样不知道如何能退更多税，我也是无意中和小伙伴聊的时候才发现这个，如何能退更多税取决于 专项附加扣除，这个合计值越多，退的也会更多，下面咱们来详细说说这个专项附加扣除，怎么能够让这个合计值变多。

专项附加扣除填报

首先打开个人所得税APP，点击下面的tabbar办税，然后点击专项附加扣除填报，就会出现如下图，通过填报上面的这些去进行增加专项附加扣除合计值。

租房租金(和房贷只能二选一)

• 要求：工作租房子了 (不需要合同也能填哦)


• 扣除标准：省会或者直辖市 1500 / 月，二线城市 1100 /月，小城市 800 /月


• 年总计：省会或者直辖市 18000，二线城市 13200，小城市 9600


• 划重点： 多段租房经历可以多填几个租房，一定要填满！！！，一定要填，没租房子也可以填，随便填一个地址也行，这个不需要租房合同，也无法追查到的，但是和贷款只能二选一，具体选哪个请继续看。

住房贷款利息(和租房只能二选一)

• 要求：首套房贷款


• 扣除标准：1000/月


• 年总计：12000


• 划重点： 和租房二选一哦，具体选哪个看你所在的城市，哪个钱多选哪个~

子女教育

• 要求：子女处于全日制学历教育阶段（幼儿园+小学+中学+大学），年龄>3岁。


• 扣除标准：每人每月 1000 元 (两个孩子是一个月2000哦)


• 年总计：12000（一个孩子的情况下）

继续教育

• 要求：考证或者学历提升


• 扣除标准：考证拿到证的当年一次性扣除：3600，学历提升 400/月


• 年总计：考证：3600，学历提升：4800


• 划重点： 这里的证必须是收录在 国家资格目录 的证书哦~

大病医疗

如果可以，我希望这个没有人申请，身体健康比什么都重要。

• 要求：医保报销后个人花费15k+


• 扣除标准：8w内根据你个人花费，花多少这个就是多少。


• 年总计：根据实际。

赡养老人

• 要求：父母 60 岁以上


• 扣除标准：独生子女2000/月，非独生子女：和兄弟姐妹分摊 2000


• 年总计：独生子女：24000，非独生子女： 0 ~ 12000

3岁以下婴幼儿照护

• 要求：孩子 3 岁以下


• 扣除标准：每月每人 1000 (两个孩子就是2000/月哦)


• 年总计：12000（一个孩子的情况下）

如何能退更多的税

打开个人所得税APP → 我要查询 → 申报查询 → 已完成→ 选择当年的综合年度汇算→ 点击专项附加扣除合计，查看自己当年的专项附加扣除合计，可以简单计算下自己填报的专项附加扣除是否都已经填写。

PS：画重点！！！注意检查时间，我开始就是租房没填满，只写了一段租房经历，所以差点错过好几个亿，如果是2023年的填报，一定要注意你专项附加扣除是否涵盖整个2022年的日期。

有年终奖的情况

可能有些小伙伴公司会发年终奖 (如果和我一样没发年终奖，那这里可以跳过了，发年终奖的公司给我来一打)，最好选择单独计税，不过都可以试一下，综合并入和单独合计，哪个退的多用哪个。

历史申报

以前的申报如果有没补充的，现在还是可以填哦，快去看看之前的申报，说不定会有惊喜哦。

最后

如果是需要补税的情况，如果少于400是不需要补的哦，当然如果大于400，一定要快点去缴纳哦，国家都留有档案，防止影响以后征信，哈哈哈，祝大家都能退几个亿~

很多朋友都知道我技术很强，但实际上除了技术之外我的管理能力同样很出众。

虽然我年纪不大，但做了很多年实际的技术管理相关的工作。

前段时间李哥向我付费取经，他已经 30 多岁了，工作了很多年，技术也很强。但今年却刚当上公司的技术总监。原来他是技术部三把手，升职的原因是前任技术总监带着副总监一起创业去了。

因为吸收了教训，老板就找到李哥，允诺给李哥一段时间的考察期，让李哥管理整个技术团队。通过考察期后会给李哥一些股份，让李哥成为技术合伙人。李哥在这家公司干了好几年了，技术能力有目共睹，确实不错，但管理经验确实比较缺乏。老板选择他，一个是出于信任，另一个也是想培养李哥。

现在李哥虽然管着几十号人，可他并没有多少实际管理经验。很多事情总觉得做得很吃力，力不从心。

所以我就和他分享了一些自己从过去的实际操作中获得的经验。

授权

第一点就是，怎么授权？

很多刚做技术管理者的人并不喜欢放权，李哥就是这类人。

这么做有几个原因。

第一个原因是怕下属能力强，功高盖主抢风头。

第二是原因是贪权，掌控欲强，什么事都要过问。

第三个原因是怕下属能力差，怕下属做砸了。

这样就会导致一个现象，很多人拿着很高的工资，担任很高的职位，却担负不了多少责任。

李哥公司每周二、周四是发布日。发布会由李哥主持，每次发布完都要等两三个小时的线上人工验证。发布完后，李哥还要担惊受怕，生怕线上出问题。

这种事不应该让李哥具体负责，因为即使哪个服务出现故障，李哥又不懂具体的业务，也做不了什么。

李哥手底下副总监、研发经理、组长十几号人，这事应该分派下去。

所有的事情都集中到了企业主要的几个负责人身上，很容易出事。

而底下的人很容易习惯这种作风，事事找领导，没有主见和主动性。

甚至于有一次李哥不在，负责的研发经理取消了发布日当天的发布计划，因为他怕发布出问题但责任。

权利高度集中，人人不作为的公司，一定会逐渐走向衰败。

所以，权利收得太紧，就会死。

那该怎么放权？

其实很简单。

员工职责内的事情要放，员工职责外的事情不要放。

就像一个员工请半天假去医院做核酸，先汇报组长，组长通过后汇报到研发经理，再汇报到技术副总监，再报备到人事专员，同时抄送人力总监和技术总监。

这么长的流程有什么用呢？

可以我直接让李哥把流程改成员工汇报给组长，组长同步给人事专员。

出事了，直接找组长，因为人是组长带的，组长要负责。

流成越复杂，就越容易扯皮甩锅撇清责任。最后背锅的估计就是李哥这个大领导。

发布的事情也是这样，谁负责的项目，什么时候发，发布过程可能出现的问题，发布失败的后果。都应该由他承担。

这样就能做到责任清晰、效率高、权利透明。

但这样不是没有隐患，组长可能不负责任，乱批假、乱报销等等。

所以权利放得太松，就容易乱。

那如何找到合适的、对工作负责的人担任组长呢？这又是一个新的问题。我后面再讲。

激励

第二点是，怎么激励？

很多新晋管理人很容易忽略激励这一点，其实它非常重要。

团队人气的高低会直接影响工作效率和工作质量。

给大家激励，让大家朝着一个方向努力，实现共同的目标很有意义和价值。虽然它不是很明显的投入，但隐形利益真的非常巨大。

那该如何激励呢？很简单，给员工争取自己能力范围内最大的福利。

简单粗暴的说，就是奖钱。

项目提前结束，给公司节省资源。

客户满意，按时付款，没有拖欠款项。

客户非常满意，计划签订下一个合作项目的合同。