Yeah, I went to useing a Graphics gotten from the BufferStrategy to render the image, I was a little dissapointed that they did not have the option to draw a single pixel, I decided to just use a fillRect(x, y, 1, 1); Worked at a good speed even at high resolutions like 1600 x 1200.  Although now that I am useing sprites, I am having trouble becasue it seems to take a really long time to draw a buffered image to a Graphics.  Is there any way to move the image into the memory on the graphics card so that it can access it quickly?

Another thing I was wondering was weather the use of something like a blocking queue to manage FPS is a good idea.

[CODE]
int fps = 30;

LinkedBlockingQueue<Thread> bq = new LinkedBlockingQueue<Thread>(1);

while(!exit)
{
   bq.put(new Thread(updater));
   bq.peek().start();
   Thread.sleep(1000/fps);
}
[/CODE]

Then have the updater somehow remove it'self from the LinkedBlockingQueue.  It prevents more than one updater from running at the same time, but also makes the wait continue while the thread is running.

Is it a good idea to avoid creating a new BufferedImage every time an image is refreshed to avoid java garbage collection, and if so, is it a good idea to have a blank image or blank raster to reset the image to when you want to redraw it?  Is there a better way?  What I have is this.

[CODE]
import java.awt.*;
import java.awt.image.*;
import javax.swing.*;
/**
* @author Scott
*
*/
public class ScreenManager
{
   private BufferedImage bi;
   private Raster blank;
   
   private BufferStrategy bs;
   
   private int width;
   private int height;
   
   public ScreenManager(int width, int height)
   {
       JFrame screenFrame = new JFrame(String.format("%dx%d", width, height));
       screenFrame.setSize(width+6, height+24);
       screenFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       screenFrame.setResizable(false);
       screenFrame.setVisible(true);
       
       this.width = width;
       this.height = height;
       
       screenFrame.createBufferStrategy(2);
       
       bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
       blank = bi.getData();
       
       bs = screenFrame.getBufferStrategy();
       
   }
   
   public void drawPixel(int x, int y, Color c)
   {
       bi.setData(blank);
       //bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
       bi.setRGB(x,y,c.getRGB());
   }
   
   public void refresh()
   {
       render(bs.getDrawGraphics(), bi);
       bs.show();
   }
   
   public void render(Graphics g, Image i)
   {
       
       g.drawImage(i, 3, 21, null);
   }
}
[/CODE]

and

[CODE]
import java.awt.*;

/**
* @author Scott
*
*/
public class Main
{
   private int pixelX;
   private int pixelY;
   
   public static void main(String[] args)
   {
       ScreenManager sm = new ScreenManager(320, 240);
       
       for(int i = 0;i < 320; i++)
       {
           if(i == 319) i = 0;
           for(int j = 0;j < 240;j++)
           {
               if(j == 240) j = 0;
               sm.drawPixel(i, j, Color.WHITE);
               sm.refresh();
           }
       }
       
       sm.refresh();
   }
}
[/CODE]