Java.awt.EventQueue.invokeLater() : Can't understand the syntax

Question

I understand that EventQueue.invokeLater() is a function called to make the Java Swing components Thread-Safe. Also, I know that the argument to this function is an object with implements Runnable. However, I am unable to understand the syntax for this function call, i.e. this call -

EventQueue.invokeLater(()-> {
        new Screen();
    });

Here, Screen() is a class that extends JFrame.

public class Screen extends JFrame
{   
    Screen()
    {    
        setSize(1000, 1000);
        JPanel j1 = new Board();
        j1.setBounds(0,0,500, 500);
        JPanel j2 = new DiceModel();
        j2.setBounds(500, 0, 500, 500);
        add(j1);
        add(j2);
        setLayout(null);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        setVisible(true);
    }   

    public static void main(String[] args) 
    {
        EventQueue.invokeLater(()-> {
            new Screen();
        });

    }
}

This code runs as expected. Board and DiceModel are two classes I have defined that which extend JPanel.

The invocation

EventQueue.invokeLater( new Screen() );

gives the expected error that Screen is not an object of type Runnable.

So,my question is, what is the meaning of the syntax for the function call for invokeLater() ? Is it a kind of anonymous function call in Java ?

This is a *lambda function*. Question's probably a duplicate, but I can't find the target. — chrylis -cautiouslyoptimistic-, Jun 21 '17 at 02:38
Thanks a lot ! I was searching for such a kind of post, but couldn't find one. So I asked the question myself. I'll look up _lambda functions_ now. — julianff, Jun 21 '17 at 02:42
Since java 8 you can create objects of interfaces with one method by using lambda expression. Interface `Runnable` has one method `run` so it is functional interface and can be used as lambda expression — Jay Smith, Jun 21 '17 at 03:42
@julianff: You can [answer your own question](http://meta.stackoverflow.com/q/17463/163188). — trashgod, Jun 21 '17 at 11:19

score 1 · Answer 1 · answered Jun 21 '17 at 05:31

The complete Swing processing is done in a thread called EDT (Event Dispatching Thread). Therefore you would block the GUI if you would compute some long lasting calculations within this thread.

The way to go here is to process your calculation within a different thread, so your GUI stays responsive. At the end you want to update your GUI, which have to be done within the EDT. Now EventQueue.invokeLater comes into play. It posts an event (your Runnable) at the end of Swings event list and is processed after all previous GUI events are processed.

Also the usage of EventQueue.invokeAndWait is possible here. The difference is, that your calculation thread blocks until your GUI is updated. So it is obvious that this must not be used from the EDT.

Still there is Java code out there that starts a JFrame simple from the main thread. This could cause issues, but is not prevented from Swing. Most modern IDEs now create something like this to start the GUI

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
    public void run() {
        new NewJFrame().setVisible(true);
       }
    });
 }

Thanks a lot! But I already knew this much. I just didn't understand the function call as I have already posted in the question. I get it now, it is a _Lambda Function call_. — julianff, Jun 21 '17 at 06:39
Make sure to give credit when using someone else's answer: https://stackoverflow.com/questions/22534356/java-awt-eventqueue-invokelater-explained — Areeha, Jan 09 '20 at 03:54

Java.awt.EventQueue.invokeLater() : Can't understand the syntax

1 Answers1