android - GridView 在 Android 中究竟是如何回收/重用 View 的？

Question

我想我确实理解了ListView重用 View 的机制，但是对于GridView，它回收 View 的方式并不符合预期。

在我的示例中，如果适配器的 getView() 中的 convertView 不为 null，我只是简单地回收 View 。

我还记录了 View 的位置。

但奇怪的是，在我检查logcat后，我发现即使我根本没有滚动，位置0(第一个vi!ew)的 View 也不为空(第一次没有回收 View ，所以位置 0 的 convertView 应该为空，对吧？)。

更奇怪的是，在它记录了所有 54 个项目之后(你可以看到整个屏幕可以容纳 54 个 View )，它记录了几个位置 0 的循环 View

所以 GridView 回收 View 的方式让我很困惑。在我看来，它应该类似于 ListView，如果我向下滚动，顶部 View 会从屏幕上消失，然后它们会一个接一个地返回到列表底部，但在 GridView 中似乎不是。

我什至用HashMap来计算每个View的回收次数(by String to Integer Entry, Key is the toString() value of a view)，我发现回收次数是分布不均匀，有的view有30次recycle，有的只有1次......

---

修改(添加回收码和异常截图)

(Edit) even though I tried using `setImageDrawable(null)` it still throws exception, as noticed you can see the exception will be thrown no matter I called it before or after the recycle

我认为这个问题的重点是 Android 没有像我预期的那样处理回收 View ，所以我的猜测是即使 convertView 不为空，也不能证明它会离开屏幕，正如你之前回答的那样，android会使用位置0的item做初始测量，所以这可能是根本原因。

**Edit Again**

适配器代码:

 package com.example.photoswalldemo;

    import android.content.Context;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.os.AsyncTask;
    import android.util.LruCache;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.AbsListView;
    import android.widget.AbsListView.OnScrollListener;
    import android.widget.ArrayAdapter;
    import android.widget.GridView;
    import android.widget.ImageView;

    import com.android.volley.RequestQueue;
    import com.android.volley.Response;
    import com.android.volley.VolleyError;
    import com.android.volley.toolbox.ImageRequest;
    import com.android.volley.toolbox.Volley;

    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.HashSet;
    import java.util.Set;

    /**
     * GridView的适配器，负责异步从网络上下载图片展示在照片墙上。
     * 
     * @author guolin
     */
    public class PhotoWallAdapter extends ArrayAdapter<String> implements OnScrollListener {

        /**
         * 记录所有正在下载或等待下载的任务。
         */
        private Set<BitmapWorkerTask> taskCollection;

        /**
         * 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。
         */
        private LruCache<String, Bitmap> mMemoryCache;

        /**
         * GridView的实例
         */
        private GridView mPhotoWall;

        /**
         * 第一张可见图片的下标
         */
        private int mFirstVisibleItem;

        /**
         * 一屏有多少张图片可见
         */
        private int mVisibleItemCount;

        /**
         * 记录是否刚打开程序，用于解决进入程序不滚动屏幕，不会下载图片的问题。
         */
        private boolean isFirstEnter = true;


        private RequestQueue queue= Volley.newRequestQueue(getContext());



        public PhotoWallAdapter(Context context, int textViewResourceId, String[] objects,
                GridView photoWall) {
            super(context, textViewResourceId, objects);
            mPhotoWall = photoWall;
            taskCollection = new HashSet<BitmapWorkerTask>();
            // 获取应用程序最大可用内存
            int maxMemory = (int) Runtime.getRuntime().maxMemory();
            int cacheSize = maxMemory / 8;
            // 设置图片缓存大小为程序最大可用内存的1/8
            mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
                @Override
                protected int sizeOf(String key, Bitmap bitmap) {
                    return bitmap.getByteCount();
                }
            };
            mPhotoWall.setOnScrollListener(this);
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
           // Log.e("Monitor View","This View is on position "+position+" and its "+convertView);
            final String url = getItem(position);
            View view;
            if (convertView == null) {
                view = LayoutInflater.from(getContext()).inflate(R.layout.photo_layout, null);
            } else {

                View tmp=convertView;

    //            ImageView tmp1=(ImageView)tmp.findViewById(R.id.photo);
    //            if(tmp1.getDrawable()!=null){
    //                //Toast.makeText(getContext(),"it has Drawable!,",Toast.LENGTH_LONG).show();
    //                Log.e("Monitor View", "This View is on position " + position + " and its view " + convertView+" and this drawable is "+tmp1.getDrawable());
    //
    //                Bitmap bitmap=((BitmapDrawable)tmp1.getDrawable()).getBitmap();
    //                tmp1.setImageDrawable(null);
    //                tmp1.setImageBitmap(null);
    //                bitmap.recycle();
    //                bitmap=null;
    //                //tmp1.setImageDrawable(null);


            //    }


                view = convertView;


            }
            final ImageView photo = (ImageView) view.findViewById(R.id.photo);
            // 给ImageView设置一个Tag，保证异步加载图片时不会乱序
            photo.setTag(url);
            setImageView(url, photo);
            return view;
        }

        /**
         * 给ImageView设置图片。首先从LruCache中取出图片的缓存，设置到ImageView上。如果LruCache中没有该图片的缓存，
         * 就给ImageView设置一张默认图片。
         * 
         * @param imageUrl
         *            图片的URL地址，用于作为LruCache的键。
         * @param imageView
         *            用于显示图片的控件。
         */
        private void setImageView(String imageUrl, ImageView imageView) {
            Bitmap bitmap = getBitmapFromMemoryCache(imageUrl);
            if (bitmap != null) {
                imageView.setImageBitmap(bitmap);
            } else {
                imageView.setImageResource(R.drawable.empty_photo);
            }
        }

        /**
         * 将一张图片存储到LruCache中。
         * 
         * @param key
         *            LruCache的键，这里传入图片的URL地址。
         * @param bitmap
         *            LruCache的键，这里传入从网络上下载的Bitmap对象。
         */
        public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
            if (getBitmapFromMemoryCache(key) == null) {
                mMemoryCache.put(key, bitmap);
            }
        }

        /**
         * 从LruCache中获取一张图片，如果不存在就返回null。
         * 
         * @param key
         *            LruCache的键，这里传入图片的URL地址。
         * @return 对应传入键的Bitmap对象，或者null。
         */
        public Bitmap getBitmapFromMemoryCache(String key) {
            return mMemoryCache.get(key);
        }

        @Override
        public void onScrollStateChanged(AbsListView view, int scrollState) {
            // 仅当GridView静止时才去下载图片，GridView滑动时取消所有正在下载的任务
            if (scrollState == SCROLL_STATE_IDLE) {
                loadBitmaps(mFirstVisibleItem, mVisibleItemCount);
            } else {
                cancelAllTasks();
            }
        }

        @Override
        public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
                int totalItemCount) {
            mFirstVisibleItem = firstVisibleItem;
            mVisibleItemCount = visibleItemCount;
            // 下载的任务应该由onScrollStateChanged里调用，但首次进入程序时onScrollStateChanged并不会调用，
            // 因此在这里为首次进入程序开启下载任务。
            if (isFirstEnter && visibleItemCount > 0) {
                loadBitmaps(firstVisibleItem, visibleItemCount);
                isFirstEnter = false;
            }
        }

        /**
         * 加载Bitmap对象。此方法会在LruCache中检查所有屏幕中可见的ImageView的Bitmap对象，
         * 如果发现任何一个ImageView的Bitmap对象不在缓存中，就会开启异步线程去下载图片。
         * 
         * @param firstVisibleItem
         *            第一个可见的ImageView的下标
         * @param visibleItemCount
         *            屏幕中总共可见的元素数
         */
        private void loadBitmaps(int firstVisibleItem, int visibleItemCount) {
            try {
                for (int i = firstVisibleItem; i < firstVisibleItem + visibleItemCount; i++) {
                    String imageUrl = Images.imageThumbUrls[i];
                    Bitmap bitmap = getBitmapFromMemoryCache(imageUrl);
                    if (bitmap == null) {
                        //BitmapWorkerTask task = new BitmapWorkerTask();
                        //taskCollection.add(task);
                        //task.execute(imageUrl);

                        //new method , use volley

                        useVolley(imageUrl);
                    } else {
                        ImageView imageView = (ImageView) mPhotoWall.findViewWithTag(imageUrl);
                        if (imageView != null && bitmap != null) {
                            imageView.setImageBitmap(bitmap);
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        /**
         * 取消所有正在下载或等待下载的任务。
         */
        public void cancelAllTasks() {
            if (taskCollection != null) {
                for (BitmapWorkerTask task : taskCollection) {
                    task.cancel(false);
                }
            }
        }

        /**
         * 异步下载图片的任务。
         * 
         * @author guolin
         */
        class BitmapWorkerTask extends AsyncTask<String, Void, Bitmap> {

            /**
             * 图片的URL地址
             */
            private String imageUrl;

            @Override
            protected Bitmap doInBackground(String... params) {
                imageUrl = params[0];
                // 在后台开始下载图片
                Bitmap bitmap = downloadBitmap(params[0]);
                if (bitmap != null) {
                    // 图片下载完成后缓存到LrcCache中
                    addBitmapToMemoryCache(params[0], bitmap);
                }
                return bitmap;
            }

            @Override
            protected void onPostExecute(Bitmap bitmap) {
                super.onPostExecute(bitmap);
                // 根据Tag找到相应的ImageView控件，将下载好的图片显示出来。
                ImageView imageView = (ImageView) mPhotoWall.findViewWithTag(imageUrl);
                if (imageView != null && bitmap != null) {
                    imageView.setImageBitmap(bitmap);
                }
                taskCollection.remove(this);
            }

            /**
             * 建立HTTP请求，并获取Bitmap对象。
             * 
             * @param imageUrl
             *            图片的URL地址
             * @return 解析后的Bitmap对象
             */
            private Bitmap downloadBitmap(String imageUrl) {
                Bitmap bitmap = null;
                HttpURLConnection con = null;
                try {
                    URL url = new URL(imageUrl);
                    con = (HttpURLConnection) url.openConnection();
                    con.setConnectTimeout(5 * 1000);
                    con.setReadTimeout(10 * 1000);
                    con.setDoInput(true);
                    con.setDoOutput(true);
                    bitmap = BitmapFactory.decodeStream(con.getInputStream());
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (con != null) {
                        con.disconnect();
                    }
                }
                return bitmap;
            }

        }



        private void useVolley(String url){

            final String tmpurl=url;

           // ImageView tmpImageView=(ImageView)mPhotoWall.findViewWithTag(tmpurl);
            ImageRequest imageRequest=new ImageRequest(url,new Response.Listener<Bitmap>() {
                @Override
                public void onResponse(Bitmap response) {

                    ImageView tmpImageView=(ImageView)mPhotoWall.findViewWithTag(tmpurl);

                    tmpImageView.setImageBitmap(response);

                    mMemoryCache.put(tmpurl,response);
                }
            },0, 0, Bitmap.Config.RGB_565, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {

                    ImageView tmpImageView=(ImageView)mPhotoWall.findViewWithTag(tmpurl);
                    //imageView.setImageResource(R.drawable.default_image);
                    tmpImageView.setImageResource(R.drawable.empty_photo);
                }
            });



            this.queue.add(imageRequest);

        }

    }

主要 Activity 代码:

public class MainActivity extends Activity {

    /**
     * 用于展示照片墙的GridView
     */
    private GridView mPhotoWall;

    /**
     * GridView的适配器
     */
    private PhotoWallAdapter adapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mPhotoWall = (GridView) findViewById(R.id.photo_wall);
        adapter = new PhotoWallAdapter(this, 0, Images.imageThumbUrls, mPhotoWall);
        mPhotoWall.setAdapter(adapter);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 退出程序时结束所有的下载任务
        adapter.cancelAllTasks();
    }

}

Answer 1

如果 View 为 null，则扩充 View ，如果 View 不为 null，则重新使用它的方式是完全正确的。这就是 AdapterView 子类实现其 View 回收的方式。

最初我很困惑，因为您对列表项 0 有一个非空 View ；但后来我想起 AdapterView 在测量和布局阶段调用适配器以获取 ListView 0 几次，甚至在显示列表项之前。这听起来没有必要，但显然 Google 开发人员这样做一定是有原因的。这也解释了为什么您会看到列表项 0 的多个日志。

至于回收不均匀，记不清views是回收FIFO还是LIFO了，不过重点是没关系。如果您指定(通过 getItemViewType() 布局相同，那么 AdapterView 交给您回收哪一个并不重要。如果您想要的只是一个铝 jar ，你真的在​​乎它是可口可乐还是百事可乐？

还要考虑到 AdapterView 最顶部的 View 通常比下方的 View 更频繁地关闭和出现在屏幕上，我认为这就是不平衡分布的原因您正在观察的 View 回收。

---

编辑:在你的异常(exception)情况下:你正在调用 bitmap.recycle() 然后设置 bitmap = null。但请记住，即使您设置了 bitmap = null，Drawable 仍然持有对现在标记为回收的位图的引用!因此，当 ImageView 尝试绘制时，它会注意到位图已被标记为已回收，因此会引发异常。如果在处理位图后调用 tmp1.setImageDrawable(null)，异常应该消失。