从事件回调通知时发生Java Swing异常

Question

So I have a GUI which acts kind of like a console. I want the user to enter text into a JTextField and press enter. I've used key bindings to make a callback for when the user presses enter.

Now I want to create a method called waitForInput() which waits for the user to enter something and returns it. What I'm trying is below. But it results in a java.lang.IllegalMonitorStateException when notify() is called in the callback function.

public class MainWindow{
    private JFrame mainWindow;
    private JTextArea textEntry;
    private String inputStringMonitor = ""; // lock/user input value
    private Boolean stringReady = false;    //flag for wait while loop


    public MainWindow(){
        mainWindow = new JFrame("console");
        textEntry = new JTextArea();

        // set up key bindings
        InputAction = new UserInputAction();
        textEntry.getInputMap().put( KeyStroke.getKeyStroke( "ENTER" ),"EnterAction" );
        textEntry.getActionMap().put( "EnterAction", InputAction);

        //configure window
        mainWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        mainWindow.setMinimumSize(new Dimension(800,675));

        mainWindow.getContentPane().add(textEntry);
        mainWindow.pack();
        mainWindow.setVisible(true);
    }



    // callback action when user presses enter
    public class UserInputAction extends AbstractAction
    {
        public void actionPerformed( ActionEvent bp )
        {
            System.out.println( "enter pressed" );
            textEntry.setText("> ");
            textEntry.setCaretPosition(2);

            synchronized(inputStringMonitor){
                stringReady = true;
                inputStringMonitor = textEntry.getText();
                inputStringMonitor.notify();  //causes exception 
            }
        }

    }


    public String waitForInput() throws InterruptedException {
        String retval = "";

        synchronized(inputStringMonitor){
            stringReady = false;
            System.out.println("waiting");
            while(!stringReady){
                inputStringMonitor.wait();
            }
            retval = inputStringMonitor;
        }

        return retval;
    } 
}

Answer 1

I think that I have an idea of what you're trying to do, and if so, I feel that I have a better solution. Correct me if I'm wrong, but I think that you want to create a GUI text entry window that other programs can use, and that notifies other programs when text as been entered. If so, then a better solution is to use a tool that is already present within Swing GUI components -- PropertyChangeSupport. If you want to listen for changes in a String's state, then make the String a "bound" property, one that notifies the GUI if its state ever changes by firing the Swing innate property change method. This way outside classes can register as listeners and be notified of this change.

For instance, the class below extends JPanel, partly because this will give the class a SwingPropertyChangeSupport object as well as add/remove PropertyChangeListener methods, but if you don't want to extend the Swing component, you can easily roll your own by adding your own SwingPropertyChangeSupport object as well as add/remove PropertyChangeListener methods to your class.

import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import javax.swing.*;

@SuppressWarnings("serial")
public class CallBackGui extends JPanel {
   // public constant for the propertyName
   public static final String TEXT_ENTRY = "text entry";

   private static final int ROWS = 20;
   private static final int COLUMNS = 40;
   private static final String CARET_MARKER = "> ";
   private JTextArea textEntryArea = new JTextArea(ROWS, COLUMNS);
   private String enteredText = ""; // "bound" property

   public CallBackGui() {
      textEntryArea.setText(CARET_MARKER);
      textEntryArea.setWrapStyleWord(true);
      textEntryArea.setLineWrap(true);
      JScrollPane scrollPane = new JScrollPane(textEntryArea);
      scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
      add(scrollPane);

      int condition = WHEN_FOCUSED;
      InputMap inputMap = textEntryArea.getInputMap(condition);
      ActionMap actionMap = textEntryArea.getActionMap();
      KeyStroke enterKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0);
      inputMap.put(enterKeyStroke, TEXT_ENTRY);
      actionMap.put(TEXT_ENTRY, new TextEntryAction());
   }

   public String getEnteredText() {
      return enteredText;
   }

   // or can make this private if you wish it to not be changed by outside forces
   public void setEnteredText(String enteredText) {
      String oldValue = this.enteredText;
      String newValue = enteredText;
      this.enteredText = enteredText; // change our bound property here

      // notify listeners here
      firePropertyChange(TEXT_ENTRY, oldValue, newValue);
   }

   // used by Key Bindings
   private class TextEntryAction extends AbstractAction {
      @Override
      public void actionPerformed(ActionEvent e) {
         // call method to set bound poperty
         setEnteredText(textEntryArea.getText().substring(CARET_MARKER.length()));
         textEntryArea.setText(CARET_MARKER);
      }
   }
}

Then any outside class that has a reference to the displayed CallBackGui can register a property change listener onto this object and get notification. A very (overly) simple example:

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;

public class TestCallBackGui {
   private static void createAndShowGui() {
      CallBackGui callBackGui = new CallBackGui();

      JFrame frame = new JFrame("CallBackGui");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.getContentPane().add(callBackGui);
      frame.pack();
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);

      // add our PropertyChangeListener
      callBackGui.addPropertyChangeListener(CallBackGui.TEXT_ENTRY, new PropertyChangeListener() {

         @Override
         public void propertyChange(PropertyChangeEvent evt) {
            System.out.println("Text Entered:");

            // result held by newValue 
            System.out.println(evt.getNewValue());
            // or can call callBackGui.getEnteredText()
         }
      });
   }

   public static void main(String[] args) {
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            createAndShowGui();
         }
      });
   }
}

The benefit -- avoidance of all low-level wait/notify/synchronized code, especially the use of this type of code on the Swing event thread, and instead use of safer higher level constructs. Also, since the Swing component actually uses a SwingPropertyChangeSupport object, all call backs will be made on the Swing event thread, an important point if the listening program is also a Swing GUI.

Answer 2

Okay. So here's a solution thanks to Titus

1) Using synchronized() in the callback blocks the EDT, so that's bad. Instead use the invokeLater() to notify asynchronously.

// thread to branch off in order to notify
Runnable doNotify = new Runnable() {
    public void run() {
        synchronized(inputStringMonitor){
            userString = textEntry.getText();
            inputStringMonitor.notify();
        }
    }
};

// callback function
public void actionPerformed( ActionEvent bp )
{
    System.out.println( "enter pressed" );
    textEntry.setText("> ");
    textEntry.setCaretPosition(2);

    SwingUtilities.invokeLater(doNotify);
}

2) Assigning to inputStringMonitor re-initializes the lock and messes things up. Instead use a dedicated lock, and a separate string for storing the actual data.