Android 方法数 65k 限制与 LinearAlloc 限制

Posted 2023-05-05

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Android 方法数 65k 限制与 LinearAlloc 限制相关的知识，希望对你有一定的参考价值。

参考技术A

较早版本的编译系统中，错误内容如下：

而在新版编译系统中，则是这样：

这个异常是 Android 应用的方法总数限制造成的。Android 平台的 Java 虚拟机 Dalvik 在执行 DEX 格式的 Java 应用程序时，使用原生类型 short 来索引 DEX 文件中的方法。这意味着单个 DEX 文件可被引用的方法总数被限制为 65536。通常 APK 仅包含一个 classes.dex 文件，因此 Android 应用的方法总数不能超过这个数量。

即使方法数没有超过 65536，能正常编译打包成 apk，在安装的时候，也有可能会提示 INSTALL_FAILED_DEXOPT 而导致安装失败，这个一般就是因为 LinearAlloc 的限制导致的。这个主要是因为 Dexopt 使用 LinearAlloc 来存储应用的方法信息。 Dalvik LinearAlloc 是一个固定大小的缓冲区。在 Android 版本的历史上，LinearAlloc 分别经历了 4M/5M/8M/16M 限制。Android 2.2 和 2.3 的缓冲区只有 5MB，Android 4.x 提高到了 8MB 或 16MB。当方法数量过多导致超出缓冲区大小时，也会造成 Dexopt 崩溃。

要解决这个问题，一般有下面几种方案：

美团的技术团队在文章中写到：

并在 AndroidManifest 中添加以下声明：

下图是 Android 的打包流程示意图：

虽然谷歌的分包方案很简单，但是效果并不是那么好，谷歌本身也枚举了分包方案的缺点：

针对上面的问题，参考网上的一些解决方案，如美团、facebook、微信等，初步使用的解决方法如下：

下面是流程图：

Android Studio 自带的 APK Analyzer，功能齐全，使用方便，使用 Android Studio APK Analyzer ，我们至少能够做到：

开发阶段使用 Android Studio 打开一个项目时，有三种方式使用 APK Analyzer 工具：

首先 dex 方法数和 dex文件有关，我们把源码编译、转化为 dex 文件时，dex 文件中会有一个区域包含了所有源码中定义或引用的方法列表，这个区域中所有方法项的总数就是方法数。之所以要考虑方法数其实是因为 Android 在设计之初只给这个区域定义了两个字节的范围（方法数量不能超过 65535 个），当超过了这个限制就会导致编译不成功，所以我们要关注方法数问题。

查看方法数可以使用命令行，也可以使用 dexcount-gradle-plugin 插件。

开发中减少方法数的实践经验主要有如下一些：

问题 1110: 2^k进制数

时间限制: 1Sec 内存限制: 128MB 提交: 812 解决: 375

题目描述

? 设r是个2^k 进制数，并满足以下条件：
（1）r至少是个2位的2^k 进制数。
（2）作为2^k 进制数，除最后一位外，r的每一位严格小于它右边相邻的那一位。
（3）将r转换为2进制数q后，则q的总位数不超过w。
在这里，正整数k（1≤k≤9）和w（k〈w≤30000）是事先给定的。

问：满足上述条件的不同的r共有多少个？
我们再从另一角度作些解释：设S是长度为w 的01字符串（即字符串S由w个“0”或“1”组成），S对应于上述条件（3）中的q。将S从右起划分为若干个长度为k 的段，每段对应一位2^k进制的数，如果S至少可分成2段，则S所对应的二进制数又可以转换为上述的2^k 进制数r。
例：设k=3，w=7。则r是个八进制数（2^3=8）。由于w=7，长度为7的01字符串按3位一段分，可分为3段（即1，3，3，左边第一段只有一个二进制位），则满足条件的八进制数有：
2位数：高位为1：6个（即12，13，14，15，16，17），高位为2：5个，…，高位为6：1个（即67）。共6+5+…+1=21个。
3位数：高位只能是1，第2位为2：5个（即123，124，125，126，127），第2位为3：4个，…，第2位为6：1个（即167）。共5+4+…+1=15个。
所以，满足要求的r共有36个。

输入

? 只有1行，为两个正整数，用一个空格隔开：
k w

输出

? 1行，是一个正整数，为所求的计算结果，即满足条件的不同的r的个数（用十进制数表示），要求最高位不得为0，各数字之间不得插入数字以外的其他字符（例如空格、换行符、逗号等）。
（提示：作为结果的正整数可能很大，但不会超过200位）

样例输入

3  7

样例输出

提示

无

代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cstdlib>
using namespace std;
const int N=60;
const int Mx=500;
const int MAXN=600+10;
struct hp
{
    int num[N];
    hp & operator = (const char*);
    hp & operator = (int);
    hp();
    hp(int);
    hp operator + (const hp &) const;
    hp operator - (const hp &) const;
    hp operator * (const hp &) const;
    hp operator / (const hp &) const;
    bool operator > (const hp &) const;
    bool operator <= (const hp &) const;
    hp & operator += (const hp &);

};
hp Cc[520];
hp one;
bool hp::operator > (const hp &b) const  //比较
{
    if(num[0]!=b.num[0]) return num[0]>b.num[0];
    for(int i=num[0];i>=1;i--)
    {
        if(num[i]!=b.num[i])
            return (num[i]>b.num[i]);
    }
    return false;
}
hp & hp::operator +=(const hp &b) {return *this=*this+b;}
bool hp::operator <= (const hp &b) const {return !(*this>b);}
hp & hp::operator = (const char *c)
{
    memset(num,0,sizeof(num));
    int n=strlen(c),j=1,k=1;
    for(int i=1;i<=n;i++)
    {
        if(k==10000) j++,k=1;
        num[j]+=k*(c[n-i]-'0');
        k*=10;
    }
    num[0]=j;
    return *this;
}
hp & hp::operator = (int a)
{
    char s[Mx];
    sprintf(s,"%d",a);
    return *this=s;
}
hp::hp() {memset(num,0,sizeof(num));num[0]=1;}
hp::hp(int n) {*this=n;}
hp hp::operator +(const hp &b) const  //加法
{
    hp c;
    c.num[0]=max(num[0],b.num[0]);
    for(int i=1;i<=c.num[0];i++)
    {
        c.num[i]+=num[i]+b.num[i];
        if(c.num[i]>=10000)
        {
            c.num[i]-=10000;
            c.num[i+1]+=1;
        }
    }
    if(c.num[c.num[0]+1]>0) c.num[0]++;
    return c;
}
hp hp::operator - (const hp &b) const  //减法
{
    hp c;
    c.num[0]=num[0];
    for(int i=1;i<=c.num[0];i++)
    {
        c.num[i]+=num[i]-b.num[i];
        if(c.num[i]<0)
        {
            c.num[i]+=10000;
            c.num[i+1]--;
        }
    }
    while(c.num[c.num[0]]==0&&c.num[0]>1) c.num[0]--;
    return c;
}
hp hp::operator * (const hp &b) const  //乘法
{
    hp c;
    c.num[0]=num[0]+b.num[0]+1;
    for(int i=1;i<=num[0];i++)
    {
        for(int j=1;j<=b.num[0];j++)
        {
            c.num[i+j-1]+=num[i]*b.num[j];
            c.num[i+j]+=c.num[i+j-1]/10000;
            c.num[i+j-1]%=10000;
        }
    }
    while(c.num[c.num[0]]==0&&c.num[0]>1) c.num[0]--;
    return c;
}
hp hp::operator / (const hp& b) const  //二分优化除法
{
    hp c,d;
    c.num[0]=num[0]+b.num[0]+1;
    d.num[0]=0;
    for(int i=num[0];i>=1;i--)
    {
        memmove(d.num+2,d.num+1,sizeof(d.num)-sizeof(int)*2);
        d.num[0]++;
        d.num[1]=num[i];
        int l=0,r=9999,mid;
        while(l<r)
        {
            mid=(l+r)>>1;
            if(b*hp(mid)<=d) l=mid+1;
            else r=mid;
        }
        c.num[i]=r-1;
        d=d-b*hp(r-1);
    }
    while(c.num[c.num[0]]==0&&c.num[0]>1) c.num[0]--;
    return c;
}
ostream & operator << (ostream & o,hp &n)  //输出
{
    o<<n.num[n.num[0]];
    for(int i=n.num[0]-1;i>=1;i--)
    {
        o.width(4);
        o.fill('0');
        o<<n.num[i];
    }
    return o;
}
int main()
{
    one=1;
    int k,w;
    cin>>k>>w;
    int x1=w/k;
    int x2=w%k;
    int M=(1<<k)-1;
    hp ans;
    hp b,v;
    Cc[0]=1;
    for(int i=1;i<=min(x1,M);i++){  //预处理了∑ C(2^k-1,i)(2<=i<=w/k) ，
        b=(M-i+1);
        v=i;
        Cc[i]=Cc[i-1]*b/v;
    }
    for(int i=2;i<=min(x1,M);i++)
    {
        ans=ans+Cc[i];
    }
    int M2=(1<<x2)-1;
    Cc[M]=Cc[min(x1,M)];
    for(int i=1;i<=M2;i++)
        {
            b=(M-i+1-x1);
            v=(M-i+1);
            Cc[M-i]=Cc[M-i+1]*b/v; //倒序计算∑ C(2^k-1-val,w/k)(1<=val<=2^(w mod k)-1) ,通过后一个数推前一个数。
            ans=ans+Cc[M-i];
        }
    cout<<ans<<endl;
    return 0;
}