金沙国际官网_金沙国际平台登录

因为这个金沙国际官网_金沙国际平台登录网站与很多的大型澳门赌场都有合作,金沙国际官网_金沙国际平台登录尽职尽责,高效执行,保持好奇心,不断学习,追求卓越,点击进入金沙国际官网_金沙国际平台登录马上体验吧,所以现在也正式地开始了营业。

您的位置:金沙国际官网 > 编程 > 学习笔记,Android内存优化之static使用篇

学习笔记,Android内存优化之static使用篇

发布时间:2020-01-05 04:46编辑:编程浏览(82)

    在Android开发中,我们经常会使用到static来修饰我们的成员变量,其本意是为了让多个对象共用一份空间,节省内存,或者是使用单例模式,让该类只生产一个实例而在整个app中使用。然而在某些时候不恰当的使用或者是编程的不规范却会造成了内存泄露现象(java上的内存泄漏指内存得不到gc的及时回收,从而造成内存占用过多的现象)

    DiskLruCache是一个十分好用的android缓存工具,我们可以从GitHub上下载其源码:https://github.com/JakeWharton/DiskLruCache

    谷歌周二发布了9月份的Android系统“平台版本”数据。数据显示,目前1/5的Android设备已运行最新版Android系统。Android“棒棒糖”系统在所有版本中所占比例突破了20%,并且是份额唯一增长的版本。而目前距离谷歌发布Nexus 9只有10个月时间。Nexus 9是首款搭载Android 5.0“棒棒糖”的产品。需要指出,这一数据来自谷歌Play商店,而访问谷歌Play商店要求用户使用Android 2.2或以上版本。

    本文中我们主要分析的是static变量对activtiy的不恰当引用而造成的内存泄漏,因为对于同一个Activity页面一般每次打开时系统都会重新生成一个该activity的对象(standard模式下),而每个activity对象一般都含有大量的视图对象和bitmap对象,如果之前的activity对象不能得到及时的回收,从而就造成了内存的泄漏现象。

    DiskLruCache所有的数据都存储在/storage/emulated/0/Android/data/应用包名/cache/XXX文件夹中(你也可以修改,但不建议这样做,原因请继续往下看),这个是android系统默认的应用缓存位置,如果应用被删除,这个文件也会一起被删除,避免应用删除后有残留数据的问题。同时,由于数据没有存储在硬盘里,所以不会影响系统性能,在sd卡里,你可以存储任意多数据。

    图片 1

    下面一边看代码一边讲解。

    由于DiskLruCache是被final修饰的,因此不可以直接通过new获得它的实例,我们使用它的open方法获得它的一个实例:
    public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)

    以下是从8月份至9月份的份额数据变化:

    单例模式不正确的获取context

    public class LoginManager {
    
        private Context context;
        private static LoginManager manager;
    
        public static LoginManager getInstance(Context context) {
            if (manager == null)
                manager = new LoginManager(context);
            return manager;
        }
    
        private LoginManager(Context context) {
            this.context = context;
        }
    

    在LoginActivity中

    public class LoginActivity extends Activity  {
    
        private LoginManager loginManager;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_login);
            loginManager = LoginManager.getInstance(this);
        }
    

    这种方式大家应该一看就明白问题在哪里了,在LoginManager的单例中context持有了LoginActivity的this对象,即使登录成功后我们跳转到了其他Activity页面,LoginActivity的对象仍然得不到回收因为他被单例所持有,而单例的生命周期是同Application保持一致的。

    正确的获取context的方式

    public class LoginManager {
    
        private Context context;
        private static LoginManager manager;
    
        public static LoginManager getInstance(Context context) {
            if (manager == null)
                manager = new LoginManager(context);
            return manager;
        }
    
        private LoginManager(Context context) {
            this.context = context.getApplicationContext();
        }
    

    修改方式也非常简单我们单例中context不再持有Activity的context而是持有Application的context即可,因为Application本来就是单例,所以这样就不会存在内存泄漏的的现象了。

    open方法需要四个参数,第一个是缓存文件文件的位置,通过下面的方法可得到:

    - Android 5.0/5.1“棒棒糖”(分别发布于2014年11月和2015年3月):份额上升2.9%,至21.0%。

    单例模式中通过内部类持有activity对象

    第一种方式内存泄漏太过与明显,相信大家都不会犯这种错误,接下来要介绍的这种泄漏方式会比较不那么容易发现,内部类的使用造成activity对象被单例持有。

    还是看代码再分析,下面是一个单例的类:

    public class TestManager {
        public static final TestManager INSTANCE = new TestManager();
        private List<MyListener> mListenerList;
    
        private TestManager() {
            mListenerList = new ArrayList<MyListener>();
        }
    
        public static TestManager getInstance() {
            return INSTANCE;
        }
    
        public void registerListener(MyListener listener) {
            if (!mListenerList.contains(listener)) {
                mListenerList.add(listener);
            }
        }
        public void unregisterListener(MyListener listener) {
            mListenerList.remove(listener);
        }
    }
    
    interface MyListener {
        public void onSomeThingHappen();
    }
    

    然后是activity:

    public class TestActivity extends AppCompatActivity {
    
        private MyListener mMyListener=new MyListener() {
            @Override
            public void onSomeThingHappen() {
            }
        };
        private TestManager testManager=TestManager.getInstance();
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_test);
            testManager.registerListener(mMyListener);
        }
    }
    

    我们知道在java中,非静态的内部类的对象都是会持有指向外部类对象的引用的,因此我们将内部类对象mMyListener让单例所持有时,由于mMyListener引用了我们的activity对象,因此造成activity对象也不能被回收了,从而出现内存泄漏现象。

    修改以上代码,避免内存泄漏,在activity中添加以下代码:`

    @Override
    protected void onDestroy() {
        testManager.unregisterListener(mMyListener);
        super.onDestroy();
    }
    
      private File getDiskCacheDir(Context context, String uniqueName) {
            String cachePath;
            //如果sd卡存在并且没有被移除
            if (Environment.MEDIA_MOUNTED.equals(Environment
                    .getExternalStorageState())
                    || !Environment.isExternalStorageRemovable()) {
                cachePath = context.getExternalCacheDir().getPath();
            } else {
                cachePath = context.getCacheDir().getPath();
            }
            return new File(cachePath + File.separator + uniqueName);
        }
    

    - Android 4.4“奇巧”(发布于2013年10月):份额下降0.1%,至39.2%。

    AsyncTask不正确使用造成的内存泄漏

    介绍完以上两种情况的内存泄漏后,我们在来看一种更加容易被忽略的内存泄漏现象,对于AsyncTask不正确使用造成内存泄漏的问题。

    mTask=new AsyncTask<String,Void,Void>()
            {
    @Override
    protected Void doInBackground(String... params) {
            //doSamething..
            return null;
            }
            }.execute("a task");
    

    一般我们在主线程中开启一个异步任务都是通过实现一个内部类其继承自AsyncTask类然后实现其相应的方法来完成的,那么自然的mTask就会持有对activity实例对象的引用了。查看AsyncTask的实现,我们会通过一个SerialExecutor串行线程池来对我们的任务进行排队,而这个SerialExecutor对象就是一个static final的常量。

    具体的引用关系是:

    1.我们的任务被封装在一个FutureTask的对象中(它充当一个runable的作用),FutureTask的实现也是通过内部类来实现的,因此它也为持有AsyncTask对象,而AsyncTask对象引用了activity对象,因此activity对象间接的被FutureTask对象给引用了。

    2.futuretask对象会被添加到一个ArrayDeque类型的任务队列的mTasks实例中

    3.mTasks任务队列又被SerialExecutor对象所持有,刚也说了这个SerialExecutor对象是一个static final的常量。

    具体AsyncTask的实现大家可以去参照下其源代码,我这里就通过文字描述一下其添加任务的实现过程就可以了,总之分析了这么多通过层层引用后我们的activity会被一个static变量所引用到。所以我们在使用AsyncTask的时候不宜在其中执行太耗时的操作,假设activity已经退出了,然而AsyncTask里任务还没有执行完成或者是还在排队等待执行,就会造成我们的activity对象被回收的时间延后,一段时间内内存占有率变大。

    解决方法在activity退出的时候应该调用cancel()函数

    @Override
    protected void onDestroy() {
        //mTask.cancel(false);
        mTask.cancel(true);
        super.onDestroy();
    }
    

    具体cancel()里传递true or false依实际情况而定:

    1.当我们的任务还在排队没有被执行,调用cancel()无论true or false,任务会从排队队列中移除,即任务都不会被执行到了。

    2.当我们的任务已经开始执行了(doInBackground被调用),传入参数为false时并不会打断doInBackground的执行,传入参数为true时,如果我们的线程处于休眠或阻塞(如:sleep,wait)状况是会打断其执行。

    这里具体解释下cancle(true)的意义:

    mTask=new AsyncTask<String,Void,Void>()
            {
    @Override
    protected Void doInBackground(String... params) {
            try {
            Thread.sleep(10000);
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
            Log.d("test", "task is running");
            return null;
            }
            }.execute("a task");
            try {
            //保证task得以执行
            Thread.sleep(2000);
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
            mTask.cancel(true);
    

    在这样的情况下我们的线程处于休眠状态调用cancel(true)方法会打断doInBackground的执行――即不会看到log语句的输出。

    但在下面的这种情况的时候却打断不了

    mTask=new AsyncTask<String,Void,Void>()
            {
    @Override
    protected Void doInBackground(String... params) {
    
            Boolean loop=true;
            while (loop) {
            Log.d("test", "task is running");
            }
            return null;
            }
            }.execute("a task");
            try {
            Thread.sleep(2000);
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
            mTask.cancel(true);
    

    由于我们的线程不处于等待或休眠的状况及时调用cancel(true)也不能打断doInBackground的执行――现象:log函数一直在打印输出。

    解决方法:

    mTask=new AsyncTask<String,Void,Void>()
            {
    @Override
    protected Void doInBackground(String... params) {
            //doSomething..
            Boolean loop=true;
            while (loop) {
            if(isCancelled())
            return null;
            Log.d("test", "task is running");
            }
            return null;
            }
            }.execute("a task");
            try {
            Thread.sleep(2000);
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
            mTask.cancel(true);
    

    这里我们通过在每次循环是检查任务是否已经被cancle掉,如果是则退出。因此对于AsyncTask我们也得注意按照正确的方式进行使用,不然也会造成程序内存泄漏的现象。

    以上内容就是在使用static时,我们需要怎么做才能优化内存的使用,当然对于以上3种情况是我们编程中使用static经常遇到的内存泄漏的情况,但仍然还有很多情况我们不易察觉到。比如:如果不做介绍,上面的第三种情况就很难察觉到,这时我们最终的内存泄漏优化方法就是:使用内存泄漏分析工具,在下一篇文章里我会参照第三种情况(AsyncTask)造成的内存泄漏,通过使用MAT工具进行分析,讲解MAT排除内存泄漏的使用方法。

    第二个参数是应用程序的版本号,要传入版本号是因为如果应用升级缓存会被清除掉。通过下面的方法可以获得程序的版本号:

    - Android 4.1/4.2/4.3“果冻豆”(分别发布于2012年7月、2012年12月、2013年7月):份额下降1.8%,至33.6%。

    private int getAppVersion(Context context) {
            try {
                PackageInfo info = context.getPackageManager().getPackageInfo(
                        context.getPackageName(), 0);
                return info.versionCode;
            } catch (NameNotFoundException e) {
                e.printStackTrace();
            }
            return 1;
        }
    

    - Android 4.0“冰激凌三明治”(发布于2011年12月):份额下降0.4%,至3.7%。

    第三个参数表示同一个key可以对应多少个缓存文件,一般情况下我们都是传1,这样key和缓存文件一一对应,查找和移除都会比较方便。

    - Android 2.3“姜饼”(发布于2011年2月):份额下降0.5%,至4.6%。

    第四个参数表示最大可以缓存多少字节的数据。

    - Android 2.2“冻酸奶”(发布于2010年5月):份额下降0.1%,至0.2%。

    打开了DiskLruCache之后,我们可以看看怎么向DiskLruCache中缓存数据:

    图片 2

    先来看看从网上down一张图片:

    不同Android系统的份额排名仍保持不变,“奇巧”位居第一,“果冻豆”第二,“棒棒糖”第三,“姜饼”第四,“冰激凌三明治”第五,“冻酸奶”第六。预计“棒棒糖”版本仍需要很长时间才能成为第一。

    private boolean downloadImg(final String urlStr,
                final OutputStream outputStream) {
            HttpURLConnection conn = null;
            BufferedOutputStream out = null;
            BufferedInputStream in = null;
            try {
                URL url = new URL(urlStr);
                conn = (HttpURLConnection) url.openConnection();
                in = new BufferedInputStream(conn.getInputStream(), 8 * 1024);
                out = new BufferedOutputStream(outputStream, 8 * 1024);
                int len = 0;
                while ((len = in.read()) != -1) {
                    out.write(len);
                }
                return true;
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (conn != null)
                    conn.disconnect();
                try {
                    if (out != null)
                        out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if (in != null)
                        in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return false;
        }
    

    与此同时,谷歌正在继续推进Android“棉花糖”版本的开发。最新版Android预计将在几周内到来,届时谷歌还将推出新的Nexus设备。而不同Android版本的份额比将再次发生变化。

    本文由金沙国际官网发布于编程,转载请注明出处:学习笔记,Android内存优化之static使用篇

    关键词:

上一篇:greenlet使用介绍及实现原理,中的线程一

下一篇:没有了