import processing.opengl.*;

ImageLoader loader;
PImage[] imageList;
int imageCount  =  1;
String path;

void setup()  {
 size(800, 600, OPENGL);

 loader  =  new ImageLoader(this);
 imageList  =  new PImage[imageCount];
path="/absolute/path/to/image.jpg"; //image can reside inside or outside the data folder
 imageList[0]  =  loader.addFile(path);
 loader.finish();
}


void draw()  {
background(255);

if(loader.isFinished())  {
 image(imageList[0],0,0);
}else{
 println("loaderNOTDone");
}

}

import java.awt.*;
import java.awt.image.*;
import java.net.URL;
import processing.core.*;


public class ImageLoader {
 PApplet parent;
 MediaTracker tracker;
 PImage[] images;
 Image[] awtImages;
 int count;
 boolean finished;

 public ImageLoader(PApplet parent) {
   this.parent = parent;
   tracker = new MediaTracker(parent);
   // Start with 100 possible elements and expand as necessary later
   images = new PImage[100];
   awtImages = new Image[100];
 }

 // This method loads images from the Internet, and can be substituted
 // for addFile when testing is finished and the application is deployed.
 public PImage addURL(String url) {
   try {
     return add(Toolkit.getDefaultToolkit().getImage(new URL(url)));
   }
   catch (Exception e) {
     e.printStackTrace();
   }
   return null;
 }

 public PImage addFile(String path) {

   return add(Toolkit.getDefaultToolkit().getImage(path));
 }

 protected PImage add(Image img) {  
   try {
     if (images.length == count) {
       // Expand the image arrays for more than 100 elements
       //images = (PImage[]) expand(images);
       //awtImages = (Image[]) expand(awtImages);
     }
     awtImages[count] = img;
     tracker.addImage(img, count);
     
     images[count] = new PImage();
   }
   catch (Exception e) {
     e.printStackTrace();
   }
   return images[count++];
 }

 public boolean isFinished() {
   if (finished) {
     return true;
   }
   if (tracker.checkAll()) {
     finish();
     return true;
   }
   return false;
 }

 public void finish() {
   try {
     tracker.waitForAll();
   }
   catch (InterruptedException e) {
   }

   for (int i = 0; i < count; i++) {
     if (!tracker.isErrorID(i)) {
       Image img = awtImages[i];
       PImage temp = new PImage(img);
       // Replace the image data without changing the PImage object reference
       images[i].width = temp.width;
       images[i].height = temp.height;
       images[i].format = temp.format;
       images[i].pixels = temp.pixels;
     }
   }
   finished = true;
 }
}

any updates on this

PImage loadImageAsync(String filename) {
 PImage vessel = createImage(0, 0, ARGB);
 AsyncImageLoader ail = new AsyncImageLoader(this, filename, vessel);
 ail.start();
 return vessel;
}

import processing.core.*;

public class AsyncImageLoader extends Thread {
 static int loaderMax = 4;
 static int loaderCount;

 PApplet parent;
 String filename;
 PImage vessel;
 
 public AsyncImageLoader(PApplet parent, String filename, PImage vessel) {
   this.parent = parent;
   this.filename = filename;
   this.vessel = vessel;
 }

 public void run() {
   while (loaderCount == loaderMax) {
     try {
       Thread.sleep(10);
     } catch (InterruptedException e) { }
   }
   loaderCount++;
   
   PImage actual = parent.loadImage(filename);
   if (actual == null) {
     vessel.width = -1;
     vessel.height = -1;

   } else {
     vessel.width = actual.width;
     vessel.height = actual.height;
     vessel.format = actual.format;
     vessel.pixels = actual.pixels;
   }
   loaderCount--;
 }
}

PImage bigImage;

void setup() {
 bigImage = loadImageAsync("something.jpg");
}

void draw() {
 if (bigImage.width == 0) {
   // image is not yet loaded
 } else if (bigImage.width == -1) {
   // this means an error occurred during image loading
 } else {
   // image is ready to go, draw it
   image(bigImage, 0, 0);
 }
}