Оптимизация отображения массивов фотографий

public class SlideView extends View
{
    private String[] imPath;
    private Bitmap[] photoArray;
    private Bitmap black;
    private int arrLength,h,w;
    private float k=0.45f,x;
    private Timer tiSlide;
    
    public SlideView(Context context, AttributeSet attributeSet)
    {
        super(context, attributeSet);
        black=BitmapFactory.decodeResource(getResources(), R.drawable.photo);
    }
    public void startAnimation(String[] array, int height, int width)
    {
        h=height; w=width;
        arrLength=array.length;
        imPath=array;
        loadRes();
        tiSlide = new Timer();
        tiSlide.schedule(new TimerTask() {
            @Override
            public void run() {
                tiSpeedMethod();
            }
        },0,40);
    }
    private void tiSpeedMethod()
    {
        this.post(speedRun);
    }
    private Runnable speedRun = new Runnable() {
        @Override
        public void run() {
            invalidate();
        }
    };
    private void loadRes()
    {
        photoArray=new Bitmap[arrLength];
        black=BitmapFactory.decodeResource(getResources(), R.drawable.photo);
        for(int i=0;i<arrLength;i++)
        {
            try{
                photoArray[i]=BitmapFactory.decodeFile(imPath[i]);
                photoArray[i]=getResizedBitmap(photoArray[i],h,w);
            } catch(Exception ex)
            {
                Log.i("MyLog","bitmap load err "+ex);
            }
        }
    }
    public Bitmap getResizedBitmap(Bitmap bm, int newHeight, int newWidth)
    {
        int width = bm.getWidth();
        int height = bm.getHeight();
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;
        Matrix matrix = new Matrix();
        matrix.postScale(scaleWidth, scaleHeight);
        Bitmap resizedBitmap = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, false);
        return resizedBitmap;
    }
    @Override
    protected void onDraw(Canvas canvas)
    {
        super.onDraw(canvas);
        Paint p=new Paint();
        if(photoArray!=null)
        {
            x-=k;
            if(x<-1*w*(arrLength)) x=0;
            try{
            for(int i=0;i<photoArray.length;i++)
            {
                canvas.drawBitmap(photoArray[i],x+w*i,0,p);
            }
            canvas.drawBitmap(photoArray[0],x+w*(arrLength),0,p);
            }catch (Exception ex){canvas.drawBitmap(black,0,0,p);}
        }
        else
            canvas.drawBitmap(black,0,0,p);
    }
}

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
 
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.os.AsyncTask;
 
public class LoadPicture extends AsyncTask<Void, Void, Boolean> {
    private Queue<Bitmap> photos;
    private int height;
    private int width;
    private String imgPath;
 
    public LoadPicture(Queue<Bitmap> photos, String imgPath, int height, int width) {
        super();
        this.photos = photos;
        this.height = height;
        this.width = width;
        this.imgPath = imgPath;
    }
 
    @Override
    protected Boolean doInBackground(Void... params) {
        return photos.add(loadBitmap());
    }
 
    private Bitmap getResizedBitmap(Bitmap bm, int newHeight, int newWidth) {
        int width = bm.getWidth();
        int height = bm.getHeight();
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;
        Matrix matrix = new Matrix();
        matrix.postScale(scaleWidth, scaleHeight);
        Bitmap resizedBitmap = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, false);
        return resizedBitmap;
    }
 
    private Bitmap loadBitmap() {
        return getResizedBitmap(BitmapFactory.decodeFile(this.imgPath), height, width);
    }
 
    static class Test {
        public static void main(String[] args) {
            // сама очередь, должна быть глобальной
            Queue<Bitmap> photos = new ConcurrentLinkedQueue<Bitmap>();
            
            // грузим в очередь
            new LoadPicture(photos, "path_to_img", 800, 480).execute();
            
            // потом юзаем эту фотку
            Bitmap img = photos.peek();
            showImg(img);
            // когда отпоказывали 
            photos.remove(img);
            
        }
        
        private static void showImg(Bitmap bmp) {
            // заглушка
        }
    }
}