Android-单线程轮循机制批量下载图片、图片压缩、内存泄漏、图片缓存、文件缓存

ListView异步批量加载图片

单线程轮循机制批量下载图片

例如：imageloader框架底层也是这么实现的！

思路：主线程向任务集合添加一个任务，工作线程从任务集合移除第一个任务，如果有任务一直移除，一直轮循，拿到图片之后解析成Bitmap,呈现的imageView当中。

package com.tarena.musicclient.adapter;

import java.io.IOException;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.util.EntityUtils;

import com.tarena.musicclient.activity.R;
import com.tarena.musicclient.entity.Music;
import com.tarena.musicclient.util.BitmapUtils;
import com.tarena.musicclient.util.GlobalConsts;
import com.tarena.musicclient.util.HttpUtils;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Message;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;

public class MusicAdapter extends BaseAdapter{
    private Context context;
    private List<Music> musics;
    private LayoutInflater inflater;
    //（2）声明任务集合  
    private List<ImageLoadTask> tasks=new ArrayList<ImageLoadTask>();
    private ListView listView;
    //声明用于轮循任务集合的工作线程
    private Thread workThread;
    //声明变量控制while循环
    private boolean isLoop=true;
    //声明缓存集合
    private HashMap<String, SoftReference<Bitmap>> cache 
        =new HashMap<String, SoftReference<Bitmap>>();

    //声明Handler  更新ImageView
    private Handler handler=new Handler(){
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
            case HANDLER_LOAD_IMAGE_SUCCESS:
                //给ImageView设置Bitmap
                ImageLoadTask task=(ImageLoadTask)msg.obj;
                //通过tag寻找到相应的ImageView
                ImageView ivAlum=(ImageView)listView.findViewWithTag(task.position);
                if(ivAlum!=null){
                    if(task.bitmap!=null){
                        ivAlum.setImageBitmap(task.bitmap);
                    }else{
                        ivAlum.setImageResource(R.drawable.ic_launcher);
                    }
                }
                break;
            }
        }
    };

    public static final int HANDLER_LOAD_IMAGE_SUCCESS=0;


    public MusicAdapter(Context context, List<Music> musics, ListView listView) {
        this.context=context;
        this.musics=musics;
        this.listView=listView;
        inflater=LayoutInflater.from(context);
        //（5）MusicAdapter有几个，工作线程就有几个
        //对workThread进行初始化
        workThread=new Thread(){
            public void run() {
                //（6）不断轮循任务集合
                while(isLoop){
                    //如果任务集合不是空集  
                    if(!tasks.isEmpty()){
                        //获取任务对象并且发送请求 
                        ImageLoadTask task = tasks.remove(0);
                        //通过路径返回Bitmap对象
                        Bitmap bitmap=loadBitmap(task.path);
                        task.bitmap=bitmap;
                        //给相应的ImageView设置Bitmap   handler
                        Message msg=new Message();
                        msg.what=HANDLER_LOAD_IMAGE_SUCCESS;
                        msg.obj=task;
                        handler.sendMessage(msg);
                    }else{
                        //同步代码块：一但调用了某个对象的wait()/notify()方法后，外面一定套一个以这个对象为锁的同步代码块
                        synchronized (workThread) {
                            //如果任务集合是空集  wait等待
                            try {
                                workThread.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        };
        workThread.start();
    }

    /**
     * 通过path  获取Bitmap
     * @param path
     * @return
     */
    public Bitmap loadBitmap(String path){
        Bitmap bitmap=null;
        String uri=GlobalConsts.BASEURL+path;
        try {
            //实体转成字节数组，字节数组转成图片
            HttpEntity entity=HttpUtils.send(HttpUtils.METHOD_GET, uri, null);
            byte[] bytes=EntityUtils.toByteArray(entity);
            bitmap=BitmapUtils.loadBitmap(bytes, 50, 50);
            //向缓存集合中存储缓存图片
            cache.put(path, new SoftReference<Bitmap>(bitmap));

        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    @Override
    public int getCount() {
        return musics.size();
    }

    public Object getItem(int position) {
        return musics.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    public View getView(int position, View convertView, ViewGroup parent) {
        ViewHolder holder=null;
        if(convertView==null){
            convertView=inflater.inflate(R.layout.item_lv_music, null);
            holder=new ViewHolder();
            holder.ivAlbum=(ImageView)convertView.findViewById(R.id.imageView1);
            holder.tvName=(TextView)convertView.findViewById(R.id.tvName);
            holder.tvDuration=(TextView)convertView.findViewById(R.id.tvDuration);
            holder.tvSinger=(TextView)convertView.findViewById(R.id.tvSinger);
            holder.tvAuthor=(TextView)convertView.findViewById(R.id.tvAuthor);
            convertView.setTag(holder);
        }
        holder=(ViewHolder)convertView.getTag();
        //给控件赋值
        Music music=musics.get(position);
        holder.tvName.setText(music.getName());
        holder.tvSinger.setText(music.getSinger());
        holder.tvAuthor.setText(music.getAuthor());
        holder.tvDuration.setText(music.getDurationtime());
        //给当前item中的ImageView设置一个Tag
        //用于图片下载完成后根据该tag
        //找到相应的ImageView
        holder.ivAlbum.setTag(position);
        //查询缓存中是否有图片 如果有 则直接获取
        SoftReference<Bitmap> ref=cache.get(music.getAlbumpic());
        if(ref!=null && ref.get()!=null){
            Bitmap bitmap=ref.get();
            holder.ivAlbum.setImageBitmap(bitmap);
            System.out.println("从缓存中读取图片..");
            return convertView;
        }
        //（3）下载一张图片  
        //向任务队列中添加一个图片任务
        ImageLoadTask task=new ImageLoadTask();
        //albumPic:   images/xxxxx.jpg
        task.path=music.getAlbumpic();
        task.position=position;
        tasks.add(task);
        //（4）唤醒工作线程  起来干活
        notifyWorkThread();
        return convertView;
    }
    /**
     * 唤醒工作线程
     */
    public void notifyWorkThread(){
    //注意：一但调用wait活notify方法的时候，就要在这个同步代码块对象上加锁
        synchronized (workThread) {
            workThread.notify();
        }
    }

    //（1）创建图片下载任务类型的类
    class ImageLoadTask{
        String path;//图片路径
        Bitmap bitmap;//图片对象
        int position; 
    }

    class ViewHolder{
        ImageView ivAlbum;
        TextView tvName;
        TextView tvDuration;
        TextView tvSinger;
        TextView tvAuthor;
    }

    public void stopWorkThread() {
        isLoop=false;
        notifyWorkThread();
    }
}

图片压缩

图片压缩的意义：（像一些小图标，不需要很高清）
例如我们写的上面的程序图片都是从服务器端下载下来的，一个图片大小是5k,但是这个5k的图片加载到内存里就不止是5k了，一个Bitmap肯定比5k要多(5k的十倍)50k，10张就500k（半兆），这样图片多了的话就非常浪费内存，占用内存！当占用内存十分大的时候，android 手机就会出现GC(垃圾回收机制)，自动销毁堆内存中的垃圾。如果java管理的内存越来越满，快溢出了，GC执行频率会上升，导致效果：在GC执行垃圾回收的时候，所有的线程暂停，主线程也不准绘制UI！如果GC执行频率非常频繁，肯定会出现吊帧，卡顿的现象！

Bitmap图片（位图对象）：

BitmapFactory 图片工厂：

Options封装了创建Bitmap对象时使用的参数

package com.tarena.musicclient.adapter;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.util.EntityUtils;

import com.tarena.musicclient.activity.R;
import com.tarena.musicclient.entity.Music;
import com.tarena.musicclient.util.BitmapUtils;
import com.tarena.musicclient.util.GlobalConsts;
import com.tarena.musicclient.util.HttpUtils;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Message;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;

public class MusicAdapter extends BaseAdapter{
    private Context context;
    private List<Music> musics;
    private LayoutInflater inflater;
    //声明任务集合  
    private List<ImageLoadTask> tasks=new ArrayList<ImageLoadTask>();
    private ListView listView;
    //声明用于轮循任务集合的工作线程
    private Thread workThread;
    //声明Handler  更新ImageView
    private Handler handler=new Handler(){
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
            case HANDLER_LOAD_IMAGE_SUCCESS:
                //给ImageView设置Bitmap
                ImageLoadTask task=(ImageLoadTask)msg.obj;
                //通过tag寻找到相应的ImageView
                ImageView ivAlum=(ImageView)listView.findViewWithTag(task.position);
                if(ivAlum!=null){
                    if(task.bitmap!=null){
                        ivAlum.setImageBitmap(task.bitmap);
                    }else{
                        ivAlum.setImageResource(R.drawable.ic_launcher);
                    }
                }
                break;
            }
        }
    };

    public static final int HANDLER_LOAD_IMAGE_SUCCESS=0;


    public MusicAdapter(Context context, List<Music> musics, ListView listView) {
        this.context=context;
        this.musics=musics;
        this.listView=listView;
        inflater=LayoutInflater.from(context);
        //对workThread进行初始化
        workThread=new Thread(){
            public void run() {
                //不断轮循任务集合
                while(true){
                    //如果任务集合不是空集  
                    if(!tasks.isEmpty()){
                        //获取任务对象并且发送请求 
                        ImageLoadTask task = tasks.remove(0);
                        Bitmap bitmap=loadBitmap(task.path);
                        task.bitmap=bitmap;
                        //给相应的ImageView设置Bitmap   handler
                        Message msg=new Message();
                        msg.what=HANDLER_LOAD_IMAGE_SUCCESS;
                        msg.obj=task;
                        handler.sendMessage(msg);
                    }else{
                        synchronized (workThread) {
                            //如果任务集合是空集  wait等待
                            try {
                                workThread.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        };
        workThread.start();
    }

    /**
     * 通过path  获取Bitmap
     * @param path
     * @return
     */
    public Bitmap loadBitmap(String path){
        Bitmap bitmap=null;
        String uri=GlobalConsts.BASEURL+path;
        try {
            HttpEntity entity=HttpUtils.send(HttpUtils.METHOD_GET, uri, null);
            byte[] bytes=EntityUtils.toByteArray(entity);
            /**
             *图片压缩处理，工具类工具方法（传个来字节数字，和宽度、高度）
             **/
            bitmap=BitmapUtils.loadBitmap(bytes, 50, 50);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    @Override
    public int getCount() {
        return musics.size();
    }

    public Object getItem(int position) {
        return musics.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    public View getView(int position, View convertView, ViewGroup parent) {
        ViewHolder holder=null;
        if(convertView==null){
            convertView=inflater.inflate(R.layout.item_lv_music, null);
            holder=new ViewHolder();
            holder.ivAlbum=(ImageView)convertView.findViewById(R.id.imageView1);
            holder.tvName=(TextView)convertView.findViewById(R.id.tvName);
            holder.tvDuration=(TextView)convertView.findViewById(R.id.tvDuration);
            holder.tvSinger=(TextView)convertView.findViewById(R.id.tvSinger);
            holder.tvAuthor=(TextView)convertView.findViewById(R.id.tvAuthor);
            convertView.setTag(holder);
        }
        holder=(ViewHolder)convertView.getTag();
        //给控件赋值
        Music music=musics.get(position);
        holder.tvName.setText(music.getName());
        holder.tvSinger.setText(music.getSinger());
        holder.tvAuthor.setText(music.getAuthor());
        holder.tvDuration.setText(music.getDurationtime());
        //给当前item中的ImageView设置一个Tag
        //用于图片下载完成后根据该tag
        //找到相应的ImageView
        holder.ivAlbum.setTag(position);

        //下载一张图片  
        //向任务队列中添加一个图片任务
        ImageLoadTask task=new ImageLoadTask();
        //albumPic:   images/xxxxx.jpg
        task.path=music.getAlbumpic();
        task.position=position;
        tasks.add(task);
        //唤醒工作线程  起来干活
        notifyWorkThread();
        return convertView;
    }
    /**
     * 唤醒工作线程，起来运行跳出循环
     */
    public void notifyWorkThread(){
        synchronized (workThread) {
            workThread.notify();
        }
    }


    class ImageLoadTask{
        String path;
        Bitmap bitmap;
        int position;
    }

    class ViewHolder{
        ImageView ivAlbum;
        TextView tvName;
        TextView tvDuration;
        TextView tvSinger;
        TextView tvAuthor;
    }
}

图片压缩工具类

package com.tarena.musicclient.util;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;

public class BitmapUtils {

    /**
     * 通过字节数组解析出Bitmap对象
     * 需要按照一定的宽高的规格进行压缩
     * @param bytes  数据源
     * @param width  图片的目标宽度
     * @param height  图片的目标高度
     * @return
     */
    public static Bitmap loadBitmap(byte[] bytes, int width, int height) {
        Options opt=new Options();
        //设置是否仅仅加载边界属性
        opt.inJustDecodeBounds=true;
        BitmapFactory.decodeByteArray(bytes, 0, bytes.length, opt);
        //获取图片的原始的高度与宽度
        int w=opt.outWidth/width;
        int h=opt.outHeight/height;
        int scale=w>h ? w : h;
        //设置压缩比例
        opt.inSampleSize=scale;
        //再次进行解析Bitmap
        opt.inJustDecodeBounds=false;
        return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, opt);
    }

}

Android 内存泄漏

Android内存当中有垃圾对象，这些垃圾对象被占用了之后还不能被GC(垃圾回收机制回收)内存也不能重复利用，导致内存泄漏。
GC垃圾回收机制:

项目中内存泄漏中的地方：

解决方法：
在Activity生命周期方法中销毁的时候关闭当前线程，详情看上方代码

内存泄漏最常见的情况：
Thread
new Thread (){}.start()必须给出run方法执行完毕的条件，在应用程序退出的时候销毁工作线程。

查看本程序中运行的线程

Java中的引用

强引用： StrongReference
e=new Emp();
就算出OOM，也不会销毁强引用
软引用： SoftReference
弱java管理的内存接近阈值，将会销毁一些软引用。释放内存
弱引用： WeakReference
就算java管理的内存没有接近阈值，就会销毁一些弱引用。
虚引用： …………
由GC管理的。

软引用的使用：
SoftReference s=new SoftReference(bitmap);
Bitmap bitmap=s.get();

Android图片的内存缓存

第一次把图片下载到手机后，存入内存中，再次需要下载图片时，先去内存中查询，如果已经下载过，那么直接获取，如果没有获取过，再去下载。
存：
注意：
一直存会容易c内存溢出OOM
HashMap < String,Bitmap > cache ;
cache.put(“images/jsjs.jpg”,bitmap)；
cache.put(“images/jsjs.jpg”,bitmap)；
cache.put(“images/jsjs.jpg”,bitmap)；
cache.put(“images/jsjs.jpg”,bitmap)；
cache.put(“images/jsjs.jpg”,bitmap)；
WeakHashMap:
弱引用，当java的内存达到阈值的时候，会随机删除键值对。
取：
Bitmap bitmap=cache.get(“images/jsjs.jpg”)；
改进后：
HashMap < String,SoftReference> map;
map.put(path,new SoftReference(bitmap));
map.get(path).get();
代码参考上方例子

图片的文件缓存

(1)下载图片后，把图片数据保存到应用的缓存目录中。

public void save(File targetFile,Bitmap bitmap)//工具类存的方法

Bitmap bitmap;
FileOutputStream fos;//写出到文件
file.write();
//缓存目录都存到cach文件中
bimap.compress();//压缩方法

(2)再次获取图片时，先去内存缓存中去查询，如果没有则去缓存目录中查询。有则直接读取。没有的话再次发送请求。

public Bitmap loadBitmap(path)//工具类方法：通过路径加载bitmap，也可以出入压缩的比例

String path;
BitmapFactory.decodeFile(path,Options);

文件缓存工具类方法：

package com.tarena.musicclient.util;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;

public class BitmapUtils {

    /**
     * 通过一个文件路径  查找到Bitmap
     * @param path
     * @return
     * @throws IOException
     */
    public static Bitmap  loadBitmap(String path)throws IOException{
        File file=new File(path);
        if(file.exists()){
            return BitmapFactory.decodeFile(path);
        }
        return null;
    }

    /***
     * 保存图片
     * @param targetFile  目标文件
     * @param bitmap  位图对象
     * @throws IOException  
     */
    public static void save(File targetFile, Bitmap bitmap)throws IOException{
        if(!targetFile.getParentFile().exists()){
            //父目录不存在 则创建
            targetFile.getParentFile().mkdirs();
        }
        if(!targetFile.exists()){
            targetFile.createNewFile();
        }
        //写入
        FileOutputStream fos=new FileOutputStream(targetFile);
        bitmap.compress(CompressFormat.JPEG, 100, fos);
    }

    /**
     * 通过字节数组解析出Bitmap对象
     * 需要按照一定的宽高的规格进行压缩
     * @param bytes  数据源
     * @param width  图片的目标宽度
     * @param height  图片的目标高度
     * @return
     */
    public static Bitmap loadBitmap(byte[] bytes, int width, int height) {
        Options opt=new Options();
        //设置是否仅仅加载边界属性
        opt.inJustDecodeBounds=true;
        BitmapFactory.decodeByteArray(bytes, 0, bytes.length, opt);
        //获取图片的原始的高度与宽度
        int w=opt.outWidth/width;
        int h=opt.outHeight/height;
        int scale=w>h ? w : h;
        //设置压缩比例
        opt.inSampleSize=scale;
        //再次进行解析Bitmap
        opt.inJustDecodeBounds=false;
        return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, opt);
    }

}

使用：

package com.tarena.musicclient.adapter;

import java.io.File;
import java.io.IOException;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.util.EntityUtils;

import com.tarena.musicclient.activity.R;
import com.tarena.musicclient.entity.Music;
import com.tarena.musicclient.util.BitmapUtils;
import com.tarena.musicclient.util.GlobalConsts;
import com.tarena.musicclient.util.HttpUtils;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;

public class MusicAdapter extends BaseAdapter{
    private Context context;
    private List<Music> musics;
    private LayoutInflater inflater;
    //声明任务集合  
    private List<ImageLoadTask> tasks=new ArrayList<ImageLoadTask>();
    private ListView listView;
    //声明用于轮循任务集合的工作线程
    private Thread workThread;
    //声明变量控制while循环
    private boolean isLoop=true;
    //声明缓存集合
    private HashMap<String, SoftReference<Bitmap>> cache 
        =new HashMap<String, SoftReference<Bitmap>>();

    //声明Handler  更新ImageView
    private Handler handler=new Handler(){
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
            case HANDLER_LOAD_IMAGE_SUCCESS:
                //给ImageView设置Bitmap
                ImageLoadTask task=(ImageLoadTask)msg.obj;
                //通过tag寻找到相应的ImageView
                ImageView ivAlum=(ImageView)listView.findViewWithTag(task.position);
                if(ivAlum!=null){
                    if(task.bitmap!=null){
                        ivAlum.setImageBitmap(task.bitmap);
                    }else{
                        ivAlum.setImageResource(R.drawable.ic_launcher);
                    }
                }
                break;
            }
        }
    };

    public static final int HANDLER_LOAD_IMAGE_SUCCESS=0;


    public MusicAdapter(Context context, List<Music> musics, ListView listView) {
        this.context=context;
        this.musics=musics;
        this.listView=listView;
        inflater=LayoutInflater.from(context);
        //对workThread进行初始化
        workThread=new Thread(){
            public void run() {
                //不断轮循任务集合
                while(isLoop){
                    //如果任务集合不是空集  
                    if(!tasks.isEmpty()){
                        //获取任务对象并且发送请求 
                        ImageLoadTask task = tasks.remove(0);
                        Bitmap bitmap=loadBitmap(task.path);
                        task.bitmap=bitmap;
                        //给相应的ImageView设置Bitmap   handler
                        Message msg=new Message();
                        msg.what=HANDLER_LOAD_IMAGE_SUCCESS;
                        msg.obj=task;
                        handler.sendMessage(msg);
                    }else{
                        synchronized (workThread) {
                            //如果任务集合是空集  wait等待
                            try {
                                workThread.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        };
        workThread.start();
    }

    /**
     * 通过path  获取Bitmap
     * @param path
     * @return
     */
    public Bitmap loadBitmap(String path){
        Bitmap bitmap=null;
        String uri=GlobalConsts.BASEURL+path;
        try {
            HttpEntity entity=HttpUtils.send(HttpUtils.METHOD_GET, uri, null);
            byte[] bytes=EntityUtils.toByteArray(entity);
            bitmap=BitmapUtils.loadBitmap(bytes, 50, 50);
            //向缓存集合中存储缓存图片
            cache.put(path, new SoftReference<Bitmap>(bitmap));
            //向文件缓存中存储图片
            //cacheDir:  /data/data/com.xxx.client/cache/
            //path: images/xxxx.jpg
            File targetFile=new File(context.getCacheDir(), path);
            BitmapUtils.save(targetFile, bitmap);

        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }

    @Override
    public int getCount() {
        return musics.size();
    }

    public Object getItem(int position) {
        return musics.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    public View getView(int position, View convertView, ViewGroup parent) {
        ViewHolder holder=null;
        if(convertView==null){
            convertView=inflater.inflate(R.layout.item_lv_music, null);
            holder=new ViewHolder();
            holder.ivAlbum=(ImageView)convertView.findViewById(R.id.imageView1);
            holder.tvName=(TextView)convertView.findViewById(R.id.tvName);
            holder.tvDuration=(TextView)convertView.findViewById(R.id.tvDuration);
            holder.tvSinger=(TextView)convertView.findViewById(R.id.tvSinger);
            holder.tvAuthor=(TextView)convertView.findViewById(R.id.tvAuthor);
            convertView.setTag(holder);
        }
        holder=(ViewHolder)convertView.getTag();
        //给控件赋值
        Music music=musics.get(position);
        holder.tvName.setText(music.getName());
        holder.tvSinger.setText(music.getSinger());
        holder.tvAuthor.setText(music.getAuthor());
        holder.tvDuration.setText(music.getDurationtime());
        //给当前item中的ImageView设置一个Tag
        //用于图片下载完成后根据该tag
        //找到相应的ImageView
        holder.ivAlbum.setTag(position);
        Bitmap bitmap=getCacheBitmap(music.getAlbumpic());
        if(bitmap!=null){
            holder.ivAlbum.setImageBitmap(bitmap);
            return convertView;
        }
        //下载一张图片  
        //向任务队列中添加一个图片任务
        ImageLoadTask task=new ImageLoadTask();
        //albumPic:   images/xxxxx.jpg
        task.path=music.getAlbumpic();
        task.position=position;
        tasks.add(task);
        //唤醒工作线程  起来干活
        notifyWorkThread();
        return convertView;
    }

    private Bitmap getCacheBitmap(String path){
        //查询缓存中是否有图片 如果有 则直接获取
        SoftReference<Bitmap> ref=cache.get(path);
        if(ref!=null && ref.get()!=null){
            Bitmap bitmap=ref.get();
            System.out.println("从缓存中读取图片..");
            return bitmap;
        }
        //查询文件缓存
        File targetFile=new File(context.getCacheDir(), path);
        Bitmap bitmap;
        try {
            bitmap = BitmapUtils.loadBitmap(targetFile.getAbsolutePath());
            //如果文件中查到了bitmap  
            //那么存入内存缓存
            if(bitmap!=null){
                System.out.println("从文件缓存中读取图片..");
                cache.put(path, new SoftReference<Bitmap>(bitmap));
            }
            return bitmap;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;  
    }

    /**
     * 唤醒工作线程
     */
    public void notifyWorkThread(){
        synchronized (workThread) {
            workThread.notify();
        }
    }


    class ImageLoadTask{
        String path;
        Bitmap bitmap;
        int position;
    }

    class ViewHolder{
        ImageView ivAlbum;
        TextView tvName;
        TextView tvDuration;
        TextView tvSinger;
        TextView tvAuthor;
    }

    public void stopWorkThread() {
        isLoop=false;
        notifyWorkThread();
    }
}