Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Android perficientur ipsum memoriam ipsum

memoria quaestio

• memoria tritura
• memoria Leak
• memoria redundantiam

memoria tritura

Memoria pulsatio ad creationem et interitum refert multorum rerum in brevi temporis spatio, unde in collectione frequenti purgamentorum (Garbage Collection, GC) operationes. Haec actio crebra GC multum opibus CPU occupat et applicationem pigri vel effectus degradationis causare potest.

Euismod: Curva serrata est memoria.

memoria Leak

Leak memoria incidit cum applicatio ad res quae amplius necessariae sunt, facit ut res illae a quisquiliarum collectore omittantur, ita spatium memoriae occupans quod liberari potuit. Subinde memoria effluat in memoria minus et minus available, quae tandem ad applicationes fragores vel ad degradationem evolutionis ducere potest.

memoria redundantiam

Memoria redundantia incidit cum applicatio conatus ad spatium memoriae plus collocandum est, sed ratio petitioni satisfacere non potest, quia spatium memoriae non iam satis est collocare. Solet hoc applicationis causa ad exceptionem OutOfMemoryError mittendam.

Mors Principium Deprehensio

• Memoria Profiler
• Memoria Analyzer
• LeakCanary

Memoria Profiler

• Memoria Profiler est memoria analysis instrumentum quod cum Android Studio venit.
• Aliquam lacinia purus vitae tempus ostendens progressio memoriae.
• Memoriam cognosce pinum, tritura, et magis.
• Dat facultatem capiendi acervum dumps, vis GC, et indagare memoriam prouinciis.

Memoria Analyzer

• Validus Java Acer analysis tool ad inveniendum memoriam pinum et memoriam usus.
• Genera altiore relationes, quaestiones resolvere, et plura.

LeakCanary

• Memoriae automatic Leak deprehensio.
  • LeakCanary sponte detegit scillam in his obiectis: Actio, Fragment, Visum, ViewModel, Officium.
• Officialis website: https://github.com/square/leakcanary

Memoria procuratio mechanism

Java

Java memoria structura: acervus, apparatus virtualis acervus, modus area, programma occurro, modus localis acervus.

Java memoria algorithmus redivivus:

• Mark-and-verris algorithmus;
  1. Mark objecta quae opus REDIVIVUS
  2. Recycle omnia notata uniformiter.
• Effingo algorithmus:
  1. Memoriam divide in duos vernos aequabiles.
  2. Post unum truncum memoriae adhibitum, res superstites ad alium scandalum transscribuntur.
• Collatio algorithm notati:
  1. Processus notationis idem est ac algorithmus "nota-et-verre".
  2. Superstes res movent ad unum finem.
  3. Reliquorum memoria patet.
• Collectio generationalis algorithmus:
  • Coniunge commoda algorithmarum multiplex collectio.
  • Salvus certe novarum rerum generationis humilis est et exemplum algorithmus adhibetur.
  • Superstes certe rerum in generatione antiqua alta est et nota algorithmus talis adhibetur.

Incommoda notae algorithmi: Vestigium et purgatio non sunt efficientes et magnum numerum memoriam discontinuarum fragmentorum dabunt.

Replicatio algorithmus: simplex ad efficiendum et efficax ad currendum. Incommoda: vastata dimidium spatii.

Mark-foedus algorithmus: evita memoriam ruptionis notae mundae causata et spatium temporis exemplaris algorithmi terere.

Android

Android memoria destinatio elastica, destinatio pretii et valoris certis machinis afficiuntur.

Dalvik algorithmus redivivus et algorithmus ART redivivus utrumque purgamentum collectionis machinae adhibitae sunt ad administrationem memoriae in systemate operante Android.

Dalvik algorithmus redivivus:

• Mark quod- verrunt algorithmus.
• Utilitas est quod simplex est ad efficiendum. Incommodum est quod exsecutio applicationis inter signa notati et dilucidandi gradus constitit, quod applicationes ad tempus duraturas et usus utentis afficit.

Ars redivivus algorithmus:

• Algorithmus de Collectione Compacting Garbage. Emendationes factae sunt in algorithmo notae verrunt ut spatium temporis in collectione purgamentorum redigeretur.
• Concurrente Vestigium: ARS inducit congruentem notationem periodi, quae id fieri potest simul cum applicationis executione. Hoc spatium temporis minuit ad collectionem purgamentum.
• Tersus et compaction: Per tersus tempus, ART non solum res notas digerit, sed etiam memoriam compactionis, quae res superstites res significat movet simul ad memoriam ruptionis reducendam. Ex hoc administratione memoriam efficaciorem reddit et casus memoriae prouinciis defectis minuit.
• Collectio adaptiva: ART etiam conceptum collectionis adaptivae introducit, quae significat quod automatice adaequat frequentiam et modum collectionis purgamentorum innixa applicationis morum ac memoriae usuum exemplarium. Hoc permittit ART ut melius accommodare ad varias applicationes requisita.

Mechanismum LMK:

• Minimum Memoria Interfectorem Mechanismum.
• Praecipuum eius munus est aliquos processus curriculi finire secundum quoddam prius consilium, cum memoria systematis satis est ad memoriam dimittendam et ad stabilitatem et alacritatem systematis efficiendam.

solvere

Memoria pulsatis quaestio

Simulatio quaestio codice

public class ShakeActivity extends AppCompatActivity {

    private static Handler mHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            String str = "";
            for (int i = 0; i < 10000000; i++) {
                str += i;
            }
            mHandler.sendEmptyMessageDelayed(1, 30);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_shake);
    }

    public void startClick(View view) {
        mHandler.sendEmptyMessage(1);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacksAndMessages(null);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Memoria uti ad deprehendere instrumentum Profiler

Memoria Profiler inspicere potest prouinciis memoriam, preme "Record Java/Kotlin prouinciis".

Sensus superiorum:

• Java: Memoria partita per codicem Java vel Kotlin.
• Patria: Memoria ex codice C vel C ++ partita est.
• Graphica: Memoria a graphice quiddam queue adhibita ad elementa velum (inclusa GL superficiebus, GL texturis, etc.). CPU memoriam communicavit.
• Stack: Memoria adhibita in ACERVUS NATIVUS et ACERVUS Javae in applicatione. Solet hoc facere cum quot stamina tua app currit.
• Memoria adhibita applicationibus ad codicem processus et facultates ut dex bytecode, optimized vel dex codicem compilata, .so bibliothecarum et fontium.
• Applicatio memoriam adhibet, ut ratio incerta quomodo referatur.
• Numerus Java/Kotlin applicando obiecta collocatur. Hic numerus non considerat obiecta in C vel C ++ partita.

Sequuntur significationes:

• Prouinciis: Transi malloc() or *new Numerus rerum ab operante partita.
• Deallocations: via free() or *delete Numerus rerum ab operatore tractatur.
• Prouinciis Size: Totalis amplitudo omnium prouincierum per tempus temporis delecti, in bytes.
• Deallocations Size: Magnitudo memoriae totalis per tempus temporis electae solutae, in bytes.
• Totalis Comitis: Allocations minus Deallocationes.
• Reliquis Location: Deallocations Location minus Location Deallocations.
• Magnitudo: Amplitudo omnium instantiarum in acervo, in bytes.

Analysis picturae supra:

Valores Allocationes et Deallocationes in hac provincia inter se similes sunt, et Magnitudo Pagus relative magna est, significans res saepe creari et destrui posse.

Post clicking, informationes ACERVUS vocationem videre potes, et cum codice coniuncta, colligere potes quaestionem in Handler memoriam jittere inesse.

Optimization tips

• Vitare creando et destruendo res frequenter.

Memoria Leak problema

Simulatio quaestio codice

public class CallbackManager {
    public static ArrayList<Callback> sCallbacks = new ArrayList<>();

    public static void addCallback(Callback callback) {
        sCallbacks.add(callback);
    }

    public static void removeCallback(Callback callback) {
        sCallbacks.remove(callback);
    }
}
1
2
3
4
5
6
7
8
9
10
11

public class LeakActivity extends AppCompatActivity implements Callback {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_leak);
        ImageView imageView = findViewById(R.id.imageView);
        Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.splash);
        imageView.setImageBitmap(bitmap);
        CallbackManager.addCallback(this);
    }

    @Override
    public void onOperate() {

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Utere LeakCanary instrumentum ad deprehendere

Bibliothecas dependens adde:

debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.14'
1

Post Leak memoriam incidit, LeakCanary notitias pertinentes generabit et automatice eam effundet;

Ut ex superiore figura videri potest: LeakActivity LeakActivity memoriam habet Leak, et relatio catenae relatio ostenditur.

Scilicet, tabella hprof generare etiam potes et certas informationes per instrumentum Profiler videre;

Ut ex pictura superiore videri potest: 10 puncta rimis facta sunt, inter LeakActivity.

Optimization tips

• Opportune redivivus collectionis elementa.
• Vitare static references to too many instances.
• Utere static interioribus generibus.
• Prope resource res protinus.

Bitmap ipsum

Si imaginum facultates non absolvis postquam Bitmap uteris, facile est causareMemoria effluo, unde in memoriam redundantiam。

Bitmap memoria exemplum

• Ante api10 (Android 2.3.3): res bitmap in acervo memoriae ponuntur, et notitia pixel in memoria locali ponuntur.
• Post api10: omnia in memoriam congerunt.
• Post api26 (Android8.0): pixel notitia loci memoria ponitur. Hoc dat Bitmap pixel notitiae strato indigenae ut cito emittatur una cum obiectis lavacri Javae.

Memoria redivivus:

• Ante Android 3.0, debes appellare manuallyBitmap.recycle()Praestare Bitmap redivivus.
• Incipiens ab Android 3.0, ratio administrationis memoriae plus intelligentes praebet, et in pluribus non opus est ut manually redivivus Bitmap.

Configuratione Bitmap pixel:

Memoria tenent Btimap computare;

• Bitmap # getByteCount ()
• getWidth () * getHeight () * 1 memoria pixel suscipit

Resource file directorium

Resource lima problema:

• mdpi (density medium): circiter 160dpi, 1x resource.
• hdpi (density altum): circiter 240dpi, 1.5x facultates.
• xhdpi (Extra High Densitas): Proxime 320dpi, 2x facultates.
• xxhdpi (Extra Ultra High Densitas): Proxime 480dpi, 3x facultates.
• xxxhdpi (Extra Ultra High Densitas): Proxime 640dpi, 4x facultates.

Test signum:

private void printBitmap(Bitmap bitmap, String drawable) {
    String builder = drawable +
            " Bitmap占用内存:" +
            bitmap.getByteCount() +
            " width:" +
            bitmap.getWidth() +
            " height:" +
            bitmap.getHeight() +
            " 1像素占用大小:" +
            getByteBy1px(bitmap.getConfig());
    Log.e("TAG", builder);
}

private int getByteBy1px(Bitmap.Config config) {
    if (Bitmap.Config.ALPHA_8.equals(config)) {
        return 1;
    } else if (Bitmap.Config.RGB_565.equals(config)) {
        return 2;
    } else if (Bitmap.Config.ARGB_8888.equals(config)) {
        return 4;
    }
    return 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 逻辑密度
float density = metrics.density;
// 物理密度
int densityDpi = metrics.densityDpi;
Log.e("TAG", density + "-" + densityDpi);

// 1倍图
Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), R.drawable.splash1);
printBitmap(bitmap1, "drawable-mdpi");

// 2倍图
Bitmap bitmap2 = BitmapFactory.decodeResource(getResources(), R.drawable.splash2);
printBitmap(bitmap2, "drawable-xhdpi");

// 3倍图
Bitmap bitmap3 = BitmapFactory.decodeResource(getResources(), R.drawable.splash3);
printBitmap(bitmap3, "drawable-xxhdpi");

// 4倍图
Bitmap bitmap4 = BitmapFactory.decodeResource(getResources(), R.drawable.splash4);
printBitmap(bitmap4, "drawable-xxxhdpi");

// drawable
Bitmap bitmap5 = BitmapFactory.decodeResource(getResources(), R.drawable.splash);
printBitmap(bitmap5, "drawable");
/*
        3.0-480
        drawable-mdpi Bitmap占用内存:37127376 width:2574 height:3606 1像素占用大小:4
        drawable-xhdpi Bitmap占用内存:9281844 width:1287 height:1803 1像素占用大小:4
        drawable-xxhdpi Bitmap占用内存:4125264 width:858 height:1202 1像素占用大小:4
        drawable-xxxhdpi Bitmap占用内存:2323552 width:644 height:902 1像素占用大小:4
        drawable Bitmap占用内存:37127376 width:2574 height:3606 1像素占用大小:4
         */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

illustrare;

1dp in mdpi cogitationes1px, 1dp in xhdpi machinis2px, 1dp==3px in xxhdpi notae.

Igitur, current fabrica est xxhdpi, sic latitudo eiusdem picturae sub xxhdpi resource 858, sub mdpi subsidio ampliabitur 3 vicibus et latitudo 2574, et sub xhdpi resource augebitur 1.5 temporibus ac latitudo est MCCLXXXVII.

Optimization tips

• Plures imaginum copiae constituit.
• Elige modum convenientem decoding.
• Statue cache extrue.

Source codice download