97

Let's say I have loaded an image in a bitmap object like

Bitmap myBitmap = BitmapFactory.decodeFile(myFile);

Now, what will happen if I load another bitmap like

myBitmap = BitmapFactory.decodeFile(myFile2);

What happens to the first myBitmap? Does it get Garbage Collected or do I have to manually garbage collect it before loading another bitmap, eg. myBitmap.recycle()?

Also, is there a better way to load large images and display them one after another while recycling on the way?

0xCursor
  • 2,242
  • 4
  • 15
  • 33
Anuj Tenani
  • 2,084
  • 2
  • 23
  • 31

5 Answers5

85

The first bitmap is not garbage collected when you decode the second one. Garbage Collector will do it later whenever it decides. If you want to free memory ASAP you should call recycle() just before decoding the second bitmap.

If you want to load really big image you should resample it. Here's an example: Strange out of memory issue while loading an image to a Bitmap object.

u32i64
  • 2,384
  • 3
  • 22
  • 36
Fedor
  • 43,261
  • 10
  • 79
  • 89
28

I think the problem is this: On pre-Honeycomb versions of Android, the actual raw bitmap data is not stored in VM memory but in native memory instead. This native memory is freed when the corresponding java Bitmap object is GC'd.

However, when you run out of native memory, the dalvik GC isn't triggered, so it is possible that your app uses very little of the java memory, so the dalvik GC is never invoked, yet it uses tons of native memory for bitmaps which eventually causes an OOM error.

At least that's my guess. Thankfully in Honeycomb and later, all bitmap data is stored in the VM so you shouldn't have to use recycle() at all. But for the millions of 2.3 users (fragmentation shakes fist), you should use recycle() wherever possible (a massive hassle). Or alternatively you may be able to invoke the GC instead.

Alexander Abakumov
  • 13,617
  • 16
  • 88
  • 129
Timmmm
  • 88,195
  • 71
  • 364
  • 509
21

You will need to call myBitmap.recycle() before loading the next image.

Depending on the source of your myFile (E.g. if it is something you have no control over the original size), when loading an image instead of just simply resampling some arbitrary number, you should scale the image to the display size.

if (myBitmap != null) {
    myBitmap.recycle();
    myBitmap = null;
}
Bitmap original = BitmapFactory.decodeFile(myFile);
myBitmap = Bitmap.createScaledBitmap(original, displayWidth, displayHeight, true);
if (original != myBitmap)
    original.recycle();
original = null;

I cache the displayWidth & displayHeight in a static that I initialized at the start of my Activity.

Display display = getWindowManager().getDefaultDisplay();
displayWidth = display.getWidth();
displayHeight = display.getHeight();
djunod
  • 4,876
  • 2
  • 34
  • 28
  • 3
    You don't need to call recycle(), it's just a good idea if you want to free the memory right away. – Karu May 28 '12 at 00:40
  • 16
    The accepted answer says "If you want to free memory ASAP you should call recycle()". Your answer says "You will need to call myBitmap.recycle()". There's a difference between "should" and "need to", and the latter is incorrect in this case. – Karu May 31 '12 at 00:36
  • 1
    Context is important. The question was "Also is there a better way to load large images and display them one after another recycling on the way". – djunod Jun 01 '12 at 02:57
  • 4
    As of Android 4.1, the above example may break because createScaledBitmap can return in some cases the same instance as the original one. That means you have to check that original != myBitmap before recycling original. – Jeremyfa Mar 12 '13 at 09:46
  • 1
    @Jeremyfa It only returns the original image if you specify a width & height that is identical to the original. In that case, scaling is moot, so it might as well save some processes by skipping it and returning the original image instead. It shouldn't "break" anything though... – Jabari Dec 04 '13 at 23:21
11

Once bitmap had been loaded in memory , in fact it was made by two part data. First part include some information about bitmap , another part include information about pixels of bitmap( it is maked up by byte array). First part exisits in Java used memory, second part exisits in C++ used memory. It can use each other's memory directly. Bitmap.recycle() is used to free the memory of C++. If you only do that,the GC will collection the part of java and the memory of C is always used.

Allen
  • 111
  • 1
  • 2
8

Timmmm was right.

according to : http://developer.android.com/training/displaying-bitmaps/cache-bitmap.html

In addition, prior to Android 3.0 (API Level 11), the backing data of a bitmap was stored in native memory which is not released in a predictable manner, potentially causing an application to briefly exceed its memory limits and crash.

Jian
  • 101
  • 1
  • 3