import java.util.ArrayList;
/**
 * This SSCEE shows how volatile threads can get, especially without
 * synchronization calls.  On my computer, these are the estimated averages,
 * please note that these are very, very much estimated at a glance.
 * 
 * All numbers are in millions
 * 
 * Threads : Est. Average | range
 *    2    :      12      | 11 - 13
 *    4    :      83      | 74 - 91
 *    8    :     200?     | 106 - 950
 *    16   :     200?     | 101 - 957 Peak volatility
 *    32   :     225?     | 107 - 941
 * @author Timothy Moore
 */
public class ThreadVolatilityCheck extends Thread
{
  /**
   * This counter is called by many different threads.
   */
  private static int counter = 0;
  /**
   * The threads status
   */
  private volatile boolean running;
  /**
   * Prepares the thread to be started
   */
  public ThreadVolatilityCheck()
  {
    running = true;
  }
  /**
   * UI Thread runs here
   */
  public static void main(String[] args)
  {
    int numThreads = 1; //5 threads for first run
    ArrayList<ThreadVolatilityCheck> threads = new ArrayList<ThreadVolatilityCheck>();
    for(int i = 0; i < 5; i++) //Double the threads every loop
    {
      numThreads *= 2;
      runExample(numThreads, threads);
      //Delay a bit in hopes to reduce the lag, as well as run the GC
      clearThreads(threads);
      System.out.println("Done! Running GC and delaying to reduce lag.");
      System.gc();
      try
      {
        Thread.sleep(1000);
      }catch(InterruptedException exc)
      {
        exc.printStackTrace();
        return;
      }
    }
  }
  /**
   * Run an example, reusing the arraylist.  This runs for 
   * 15 seconds, displaying the counter every second
   * @param num the number of threads
   * @param thrdList the list of threads
   */
  public static void runExample(int num, ArrayList<ThreadVolatilityCheck> thrdList)
  {
    System.out.println("Running an example that has "+num+" threads!");
    for(int i = 0; i < num; i++)
    {
      thrdList.add(new ThreadVolatilityCheck());
      thrdList.get(i).start();
    }
    //Clear it several times to make sure
 
    for(int i = 0; i < 15; i++)
    {
      try
      {
        Thread.sleep(1000);
      }catch(InterruptedException exc)
      {
        exc.printStackTrace();
        return;
      }
      System.out.println("In loop "+(i+1)+", counter was incremented "+counter+" times.");
      for(int i2 = 0; i2 < 5; i2++) //Hard to clear with the threads going on so fast
      {
        counter = 0;
        try
        {
          Thread.sleep(10);
        }catch(InterruptedException exc)
        {
          exc.printStackTrace();
          return;
        }
      }
    }
  }
  /**
   * Stops each thread, and then clears the list.
   * 
   * @param thrdList the thread list
   */
  public static void clearThreads(ArrayList<ThreadVolatilityCheck> thrdList)
  {
    if(thrdList.size() > 0)
    {
      //Clear the list
      for(int i = 0; i < thrdList.size(); i++)
      {
        thrdList.get(i).running = false;
      }
      thrdList.clear();
    }
  }
  @Override
  public void run()
  {
    while(running)
    {
      counter++;
      /*try
      {
        Thread.sleep(5);  //Use this only if you have to.  This will make results much less clear, but
      }catch(InterruptedException exc) //will remove the lag your computer might get
      {
        exc.printStackTrace();
        return;
      }*/
    }
  }
}

private static ConsoleGUI.TAScanner scanner

private static ConsoleGUI.TAPrintStream out

ConsoleGUI.toGUI();
scanner = ConsoleGUI.getScanner();
out = ConsoleGUI.getStream();

package me.timothy.consolegui;
 
import java.util.Scanner;
import javax.swing.*;
import java.awt.BorderLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.io.PrintStream;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.File;
import java.io.IOException;
import java.util.InputMismatchException;
import javax.swing.text.DefaultCaret;
 
/**
 * Turns a console program into a basic GUI program, useful
 * for Window 7 programs that are unable to open command
 * prompt with a .jar  All a class has to do in order to use 
 * this program is call the static method toGUI(), a special Scanner is
 * acquirable instead of System.in
 * (Attrievable by a call to getScanner(), which is static)
 * By a call to saveSaveText(true),  it will save the calls to out and scanner,
 * however it does not throw any exceptions and may cause lag if
 * there are a lot of System.out calls.
 * 
 * @author Timothy Moore
 */
public class ConsoleGUI extends JFrame
{
  private static volatile boolean saveRun = false;
  /**
   * The ConsoleGUI
   */
  private static ConsoleGUI gui;
  /**
   * The Scanner being used
   */
  private TAScanner scanner;
  /**
   * The stream being used
   */
  private TAPrintStream stream;
  /**
   * The main text area, where calls to System.out go
   */
  private JTextArea txtArea;
  /**
   * Where the user enters information
   */
  private JTextField userField;
  /**
   * The submit button, not actually necessary
   */
  private JButton submit;
  /**
   * The JScrollPane wrapper
   */
  private JScrollPane sPane;
  /**
   * Creates the GUI
   */
  private ConsoleGUI()
  {
    setSize(350, 350);
    setTitle("Console GUI");
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setLocationRelativeTo(null);
    setLayout(new BorderLayout());
 
    txtArea = new JTextArea();
    txtArea.setEditable(false);
    sPane = new JScrollPane(txtArea);
    add(sPane, BorderLayout.CENTER);
    userField = new JTextField();
    userField.setEditable(false);
    userField.setActionCommand("submit");
    submit = new JButton("Submit");
    submit.setActionCommand("submit");
    JPanel bot = new JPanel();
    bot.setLayout(new BorderLayout());
    bot.add(userField, BorderLayout.CENTER);
    bot.add(submit, BorderLayout.EAST);
    add(bot, BorderLayout.SOUTH);
  }
  /**
   * Sets the program to use the ConsoleGUI instead of the regular 
   * Console
   */
  public static void toGUI()
  {
    try
    {
      SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run()
        {
          gui = new ConsoleGUI();
          gui.stream = gui.createPrintStream();
          gui.setVisible(true);
        }
      });
    }catch(Exception exc)
    {
      handleException("Failed to convert to gui", exc, saveRun);
    }
 
  }
 
  public static void setConsoleTitle(String tit)
  {
    gui.setTitle(tit);
  }
  /**
   * Creates a TAPrintStream based on the text area
   */
  private TAPrintStream createPrintStream()
  {
    return new TAPrintStream(txtArea);
  }
  /**
   * @return a new TAScanner
   */
  private TAScanner createScanner()
  {
    return new TAScanner(userField, submit);
  }
  /**
   * @return the print stream
   */
  public static TAPrintStream getStream()
  {
    return gui.stream;
  }
  /**
   * Sets if it is saving the text, by default false
   * @param b if it should save text
   */
  public static void setSaveText(boolean b)
  {
    saveRun = b;
  }
  /**
   * @return the scanner to use.  Has most methods of Scanner 
   * @throws NullPointerException if called before toGUI
   */
  public static TAScanner getScanner()
  {
    if(gui.scanner == null)
      gui.scanner = gui.createScanner();
    return gui.scanner;
  }
 
  /**
   * Handles an exception with the specified message and
   * underlying throwable.  This method will handle all
   * exceptions appropriately. 
   * 
   * This method will return normally.
   * 
   * @param msg the message, can be null.
   * @param exc the exception, cannot be null
   * @param saveToFile if file io should be attempted.
   */
  public static void handleException(String msg, Throwable exc, boolean saveToFile)
  {
    try
    {
      TAPrintStream out = getStream();
 
      out.print(msg);
      out.println(" - " + exc.getClass().getSimpleName());
      StackTraceElement[] elements = exc.getStackTrace();
 
      for(StackTraceElement t : elements)
      {
        out.println(t);
      }
    }catch(Exception exce)
    {
      // Not cool.
      exce.printStackTrace();
    }
  }
  /**
   * For testing purposes, shows an example usage of this program
   */
  public static void main(String[] args)
  {
    ConsoleGUI.toGUI();
    //ConsoleGUI.setSaveText(true);
    TAScanner scanner = ConsoleGUI.getScanner();
    TAPrintStream out = ConsoleGUI.getStream();
    out.println("Type a string");
    String str = scanner.nextLine();
    out.println("Type an int");
    int i = scanner.nextInt();
    out.println("You typed "+str+" and "+i);
    out.println("Say something starting with y");
    boolean b = scanner.nextBoolean();
    out.println(b);
    out.println("Say something starting with n");
    b = scanner.nextBoolean("n", true);
    out.println(b);
    out.println("Say banana");
    b = scanner.nextBoolean("banana", false);
    out.println(b);
 
    out.println();
    RuntimeException exc = new RuntimeException();
    handleException("Test", exc, true);
    //for(int i = 0; i < 50; i++) { out.println("Purposeful Spam"); }
  }
  @Override
  public String toString()
  {
    return "initialized";
  }
  /**
   * Short for TextAreaPrintStream, this stream sends all messages
   * to the GUI instead of the regular System.out
   * 
   * @author Timothy Moore
   */
  public class TAPrintStream
  {
    private JTextArea txtArea;
    private BufferedWriter fileWriter;
    private final File file = new File("lastRun.txt");
    /**
     * Create a print stream to the specified text area
     */
    private TAPrintStream(JTextArea txtArea)
    {
      this.txtArea = txtArea;
      DefaultCaret caret = (DefaultCaret)txtArea.getCaret();
      caret.setUpdatePolicy(DefaultCaret.ALWAYS_UPDATE);
    }
 
    public void print(Object msg)
    {
      txtArea.append(msg.toString());
      if(saveRun)
      {
        if(fileWriter == null)
        {
          //System.out.println("Creating file writer");
          try
          {
 
            file.createNewFile();
            fileWriter = new BufferedWriter(new FileWriter(file));
          }catch(Exception exc)
          {
            saveRun = false;
            handleException("Failed to create file", exc, false);
          }
          Runtime.getRuntime().addShutdownHook(new Thread()
                                                   {
            @Override
            public void run()
            {
              try
              {
                fileWriter.close();
              }catch(IOException e)
              {
                handleException("Failed to close writer", e, false);
              }
            }
          });
        }
        //System.out.println("Saving to filewriter");
        try
        {
          String[] msgs = msg.toString().split("/n");
          for(String s : msgs)
          {
            fileWriter.write(s);
            fileWriter.newLine();
          }
        }catch(Exception e)
        {
          handleException("Failed to write to file", e, false);
          saveRun = false;
        }
      }
 
    }
    public void print(boolean msg)
    {
      print(new StringBuilder().append(msg));
    }
    public void print(int msg)
    {
      print(new StringBuilder().append(msg));
    }
    public void print(long msg)
    {
      print(new StringBuilder().append(msg));
    }
    public void print(double msg)
    {
      print(new StringBuilder().append(msg));
    }
 
    public void println()
    {
      print("\n");
    }
 
    public void println(Object msg)
    {
      print(new StringBuilder().append(msg).append("\n"));
    }
    public void println(int msg)
    {
      println(new StringBuilder().append(msg));
    }
    public void println(long msg)
    {
      println(new StringBuilder().append(msg));
    }
    public void println(boolean msg)
    {
      println(new StringBuilder().append(msg));
    }
    public void println(double msg)
    {
      println(new StringBuilder().append(msg));
    }
  }
  /**
   * Short for TextAreaScanner, this Scanner retrieves messages
   * from the GUI instead of the regular new Scanner(System.in)
   * 
   * @author Timothy Moore
   */
  public class TAScanner implements ActionListener
  {
    private String str;
    private JTextField field;
    private JButton but;
    /**
     * Creates a scanner based on the specified text field
     * and button
     */
    private TAScanner(JTextField field, JButton but)
    {
      this.field = field;
      this.but = but;
      field.addActionListener(this);
      but.addActionListener(this);
    }
    /**
     * Reads one string
     */
    public String readLine()
    {
      field.setEditable(true);
      str = null;
      while(str == null)
      {
        delay(100);
      }
      ConsoleGUI.getStream().println(new StringBuilder("> ").append(str));
      return str;
    }
    /**
     * Same as readLine()
     */
    public String nextLine()
    {
      return readLine();
    }
    /**
     * Same as readInt()
     */
    public int nextInt()
    {
      return readInt();
    }
    /**
     * Same as readBoolean()
     */
    public boolean nextBoolean()
    {
      return readBoolean();
    }
    /**
     * Same as readLong()
     */
    public long nextLong()
    {
      return readLong();
    }
    /**
     * @return an integer from user
     */
    public int readInt()
    {
      try
      {
        return Integer.valueOf(readLine());
      }catch(NumberFormatException exc)
      {
        throw new InputMismatchException(exc.getMessage());
      }
    }
    /**
     * @return a long from user
     */
    public long readLong()
    {
      try
      {
        return Long.valueOf(readLine());
      }catch(NumberFormatException exc)
      {
        throw new InputMismatchException(exc.getMessage());
      }
    }
    /**
     * @return a boolean from user, assuming anything starting with a y is yes
     */
    public boolean readBoolean()
    {
      return readBoolean("Y", true);
    }
    /**
     * This is not case sensitive.
     * @return a boolean from user
     * @param str the string that the response needs to be true
     * @param start if the string has to start with the string or be completely that string
     */
    public boolean readBoolean(String str, boolean start)
    {
      if(start)
      {
        return readLine().toLowerCase().startsWith(str.toLowerCase());
      }else
      {
        return readLine().equalsIgnoreCase(str);
      }
    }
    /**
     * Same as <code>readBoolean(String str, boolean str)</code>
     */
    public boolean nextBoolean(String str, boolean start)
    {
      return readBoolean(str, start);
    }
    @Override
    public void actionPerformed(ActionEvent event)
    {
      str = field.getText();
      field.setText("");
    }
  }
  /**
   * Like thread.sleep but does not throw exceptions. Use with caution
   * @param ms the time in ms
   */
  public static void delay(long ms)
  {
    try
    {
      Thread.sleep(ms);
    }catch(InterruptedException exc)
    {
 
    }
  }
}