Archive for July 18, 2008

Quick Guide to using Weak References in Java

July 18, 2008 at 1:31 pm · Filed under java

Java’s WeakReference functionality is an easy way to handle a lot of data but not have to worry about running out of memory.  Works well in lazy-initialization situations, such as when you want to be able to read in a potentially large amount of data, but that data is not important enough that you want to guarantee that it is always immediately available.

For example, say you are reading a 5 megapixel image off the disk in order to determine its size or make a thumbnail or otherwise read metadata. Or, you could be scanning files for spell checking or search terms.  Either way, you really don’t care that the original, large, source data stays in memory. If would be great if it did, for performance’s sake, but not the end of the world if it was garbage-collected.

By default, all java references are strong references — the object on the other end of a strong reference is not garbage collected until the object containing the reference is collected.  That is where java.lang.ref.WeakReference comes in. Instead of keeping your strong reference in your object, you give it to a WeakReference instance instead. It does the dirty work of allowing the reference to be collected.

You now have a strong reference to only a WeakReference object — a relative lightweight, in memory terms.  All you have to do is make sure the data is loaded when you want, and WeakRef and the GC will take care of unloading it as needed.

So, let’s take the example of reading a large file into a string, but we don’t mind re-reading the file if memory becomes tight.

The following code assumes there is a class, FileUtils, that has a method for reading the file. Implementation of that method is left as an exercise to the reader.

import java.io.File;
import java.lang.ref.WeakReference;

public class LazyFileReader {
    private WeakReference<String> fileRef;
    private final String filename;

    public LazyFileReader(String filename) {
        this.filename = filename;
    }

    private String forceLoadFileData() {
        // force initialization; create reference
        String rv = FileUtils.fileToString(new File(filename));
        // update weakRef:
        fileRef = new WeakReference<String>(rv); // **1**

        return rv;
    }

    public String getFileData() {
        String rv;

        if (fileRef == null) { // **2**
            // first loading, force:
            System.out.println("first loading: " + filename);
            rv = forceLoadFileData();

        } else {
            // load from weakRef:
            rv = fileRef.get(); // **3**
            if (rv == null) {
                System.out.println("file needs reloading: " + filename);
                rv = forceLoadFileData(); // **4**
            } // endif
        } // endif

        return rv;
    }
}

Some notes, indicated by // ** # ** comments above:

  1. Note that once a WeakReference has released its data, you can’t update the reference — you must create a new one each time.
  2. The very first time getFileData() is called, we don’t even have a WeakReference reference. This situation will only happen once.
  3. get() is the means by which you get back the reference you put in. A null value indicates that the reference was collected and therefore needs to be recreated.
  4. Note that we perform the exact same code during the first time through and the first time through after the reference was collected.

Hope that helps.

Comments off

The Power of Naming

July 18, 2008 at 12:54 pm · Filed under Family, Games

How often have you read a story where the way to defeat an enemy is to know its name?  Or seen a movie where the discovery of a name leads to control over the named object?  Some examples in popular culture:

  • Rumpelstiltskin would be the prime example here.  By learning the name, and speaking it to the creature, the miller’s daughter got out of the bargain she had made (to be able to spin straw into gold, she had to give up her firstborn).
  • In The Tenth Kingdom, the blind woodsman would only release his prisoner and give the heroes his magic axe if they could guess his name.  (Luckily, he kept it in his hat.)
  • The undoing of the Horned King in The Book of Three by Lloyd Alexander was the speaking of his name.
  • In Aidyn Chronicles for the Nintendo64, the main character Alaron lacks a True Name, which binds his body and soul together.  Without it, he is incomplete.

The question is, does any of this apply to the real world?

It was, in fact, in my playing of Aidyn Chronicles that I first became cognizant of this whole business.  In it, there is a discipline of magic called Naming set in contrast to the more familiar Elemental (fire, air, earth, water) magic.  At the time, I thought, “What’s the big deal?  Is having a name and giving a name so important?”  This was 2001.

Flash forward to 2007.  I have a daughter now, and she’s struggling to learn everything in the world.  She will eat up new words and start using them immediately.  She feels every word brings her more power.

Well, knowledge is power, names are knowledge, and therefore names are power.  So I guess it makes a bit of sense.  You can know about something.  But this is not just knowing something, it is naming that something.  If you know enough about a thing, you can name it, categorize it, relegate it.  Give a name to your fear, the saying goes.

I suspect naming can have broader powers too… a way of setting the stage for a debate, for example.  If you coin a product name, a movment, a philosophy, or anything, you may well be determining the ultimate fate of that thing.  At the very least, you’re doing a bit of mind control by making a popular name that everyone speaks.

Wikipedia has a bit more discussion in this vein, under the True Name topic.

Comments off