BufferStrategy (Java SE 26 & JDK 26)
Description: declaration: module: java.desktop, package: java.awt.image, class: BufferStrategy
Keywords: java.awt.image.BufferStrategy class

# Class BufferStrategy

java.lang.Object
java.awt.image.BufferStrategy

Direct Known Subclasses:
  `Component.BltBufferStrategy, Component.FlipBufferStrategy`

public abstract class BufferStrategy extends Object
The `BufferStrategy` class represents the mechanism with which to organize complex memory on a particular `Canvas` or `Window`. Hardware and software limitations determine whether and how a particular buffer strategy can be implemented. These limitations are detectable through the capabilities of the `GraphicsConfiguration` used when creating the `Canvas` or `Window`.

It is worth noting that the terms buffer and surface are meant to be synonymous: an area of contiguous memory, either in video device memory or in system memory.

There are several types of complex buffer strategies, including sequential ring buffering and blit buffering. Sequential ring buffering (i.e., double or triple buffering) is the most common; an application draws to a single back buffer and then moves the contents to the front (display) in a single step, either by copying the data or moving the video pointer. Moving the video pointer exchanges the buffers so that the first buffer drawn becomes the front buffer, or what is currently displayed on the device; this is called page flipping.

Alternatively, the contents of the back buffer can be copied, or blitted forward in a chain instead of moving the video pointer.

    Double buffering:

                       ***********         ***********
                       *         * ------> *         *
    [To display] <---- * Front B *   Show  * Back B. * <---- Rendering
                       *         * <------ *         *
                       ***********         ***********

    Triple buffering:

    [To      ***********         ***********        ***********
    display] *         * --------+---------+------> *         *
       <---- * Front B *   Show  * Mid. B. *        * Back B. * <---- Rendering
             *         * <------ *         * <----- *         *
             ***********         ***********        ***********

Here is an example of how buffer strategies can be created and used:

    // Check the capabilities of the GraphicsConfiguration
    ...

    // Create our component
    Window w = new Window(gc);

    // Show our window
    w.setVisible(true);

    // Create a general double-buffering strategy
    w.createBufferStrategy(2);
    BufferStrategy strategy = w.getBufferStrategy();

    // Main loop
    while (!done) {
        // Prepare for rendering the next frame
        // ...

        // Render single frame
        do {
            // The following loop ensures that the contents of the drawing buffer
            // are consistent in case the underlying surface was recreated
            do {
                // Get a new graphics context every time through the loop
                // to make sure the strategy is validated
                Graphics graphics = strategy.getDrawGraphics();

                // Render to graphics
                // ...

                // Dispose the graphics
                graphics.dispose();

                // Repeat the rendering if the drawing buffer contents
                // were restored
            } while (strategy.contentsRestored());

            // Display the buffer
            strategy.show();

            // Repeat the rendering if the drawing buffer was lost
        } while (strategy.contentsLost());
    }

    // Dispose the window
    w.setVisible(false);
    w.dispose();

Since:
  1.4
See Also:
  - `Window`
  - `Canvas`
  - `GraphicsConfiguration`
  - `VolatileImage`

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `BufferStrategy()`
  Constructor for subclasses to call.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `abstract boolean`
  `contentsLost()`
  Returns whether the drawing buffer was lost since the last call to `getDrawGraphics`.
  `abstract boolean`
  `contentsRestored()`
  Returns whether the drawing buffer was recently restored from a lost state and reinitialized to the default background color (white).
  `void`
  `dispose()`
  Releases system resources currently consumed by this `BufferStrategy` and removes it from the associated Component.
  `abstract BufferCapabilities`
  `getCapabilities()`
  Returns the `BufferCapabilities` for this `BufferStrategy`.
  `abstract Graphics`
  `getDrawGraphics()`
  Creates a graphics context for the drawing buffer.
  `abstract void`
  `show()`
  Makes the next available buffer visible by either copying the memory (blitting) or changing the display pointer (flipping).

  ### Methods declared in class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
  Modifier and Type
  Method
  Description
  `protected Object`
  `clone()`
  Creates and returns a copy of this object.
  `boolean`
  `equals(Object obj)`
  Indicates whether some other object is "equal to" this one.
  `protected void`
  `finalize()`
  Deprecated, for removal: This API element is subject to removal in a future version.
  Finalization is deprecated and subject to removal in a future release.
  `final Class<?>`
  `getClass()`
  Returns the runtime class of this `Object`.
  `int`
  `hashCode()`
  Returns a hash code value for this object.
  `final void`
  `notify()`
  Wakes up a single thread that is waiting on this object's monitor.
  `final void`
  `notifyAll()`
  Wakes up all threads that are waiting on this object's monitor.
  `String`
  `toString()`
  Returns a string representation of the object.
  `final void`
  `wait()`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted.
  `final void`
  `wait(long timeoutMillis)`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
  `final void`
  `wait(long timeoutMillis, int nanos)`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.

- ## Constructor Details

  - ### BufferStrategy

    protected BufferStrategy()
    Constructor for subclasses to call.

- ## Method Details

  - ### getCapabilities

    public abstract BufferCapabilities getCapabilities()
    Returns the `BufferCapabilities` for this `BufferStrategy`.
    Returns:
      the buffering capabilities of this strategy

  - ### getDrawGraphics

    public abstract Graphics getDrawGraphics()
    Creates a graphics context for the drawing buffer. This method may not be synchronized for performance reasons; use of this method by multiple threads should be handled at the application level. Disposal of the graphics object obtained must be handled by the application.
    Returns:
      a graphics context for the drawing buffer

  - ### contentsLost

    public abstract boolean contentsLost()
    Returns whether the drawing buffer was lost since the last call to `getDrawGraphics`. Since the buffers in a buffer strategy are usually type `VolatileImage`, they may become lost. For a discussion on lost buffers, see `VolatileImage`.
    Returns:
      Whether or not the drawing buffer was lost since the last call to `getDrawGraphics`.
    See Also:
      - `VolatileImage`

  - ### contentsRestored

    public abstract boolean contentsRestored()
    Returns whether the drawing buffer was recently restored from a lost state and reinitialized to the default background color (white). Since the buffers in a buffer strategy are usually type `VolatileImage`, they may become lost. If a surface has been recently restored from a lost state since the last call to `getDrawGraphics`, it may require repainting. For a discussion on lost buffers, see `VolatileImage`.
    Returns:
      Whether or not the drawing buffer was restored since the last call to `getDrawGraphics`.
    See Also:
      - `VolatileImage`

  - ### show

    public abstract void show()
    Makes the next available buffer visible by either copying the memory (blitting) or changing the display pointer (flipping).

  - ### dispose

    public void dispose()
    Releases system resources currently consumed by this `BufferStrategy` and removes it from the associated Component. After invoking this method, `getBufferStrategy` will return null. Trying to use a `BufferStrategy` after it has been disposed will result in undefined behavior.
    Since:
      1.6
    See Also:
      - `Window.createBufferStrategy(int)`
      - `Canvas.createBufferStrategy(int)`
      - `Window.getBufferStrategy()`
      - `Canvas.getBufferStrategy()`