标签: event-dispatch-thread

我正在开发一个简单的Java swing项目.这是主类的代码(名称已更改):

public class MainProg
{
    private static MainProg program; 

    //mainWin is a JFrame
    private MainWindow mainWin;

    //Event handler class which extends MouseAdapter
    private TrayManager trayMgr;


    public static void main(String[] args)
    {                
        program = new MainProg();
    }

    public MainProg()
    {
        mainWin = new MainWindow();
        trayMgr = new TrayManager();

        mainWin.startBtn.addMouseListener(trayMgr);

        mainWin.setVisible(true);
    }
}

很明显,当程序启动时,main()它会创建一个新的MainProg类实例,然后调用构造函数.在构造函数中,它创建JFrame的新实例mainWin.然后它将事件处理程序附加到按钮上mainWin.

在事件处理程序类中trayMgr,唯一的方法是mouseClicked()除了a之外什么都不做System.out.println('Clicked');

问题是,当我在Netbeans中运行此程序时,JFrame立即显示,但我似乎必须在控制台中打印消息之前单击按钮2-3次.

这只是Netbeans的特定内容,还是我必须更改某些内容才能在窗口可见之前设置事件处理程序？

可能重复:
java中的GUI线程

我一直在尝试创建一个基于文本的游戏,它到目前为止,除了使用Thread.sleep()和wait()时这个奇怪的错误这个代码应该通过char打印消息char到一个名为console的JTextArea延迟每一个之间.

这是带wait()的代码

int i=0;
synchronized(mon) {
    while(i<msg.length())
    {
        console.setText(console.getText()+ msg.charAt(i));
        i++;
        try {
            mon.wait(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
} 

这是带sleep()的代码:

int i=0;
    while(i<msg.length())
    {
        console.setText(console.getText()+ msg.charAt(i));
        i++;
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

但是,当它到达此代码时,程序等待msg.length*500ms然后立即打印整个msg!救命!

这主要是一个理论问题。下面的示例使我想到了它，但这可能不是最好的示例。请假设以下原因是具体的，暂时无法解决。

我正在运行的程序具有一个可选的调试框架，该框架在程序启动时创建，并且可以通过用户按按钮/键盘快捷方式使其可见。

我的问题是，由于我在EDT上的进程很长，如果它由于某种原因挂起或失败，我想立即查看，而不是等待该线程结束运行，以更新调试日志框架。

我的解决方案是让两个单独的GUI具有两个单独的EDT，并由一个单独的线程更新它们。

这可能吗，还是我做不到？我尚未找到任何可以向我展示如何使用的在线资源。我知道EDT应该是单线程的，但是如果我使线程不纠缠，我可以有两个吗？请？

我正在尝试为java创建一个程序,我有闪烁的常见问题.我尝试过很多东西要消除,但都是一样的.而我画的椭圆正在移动japplet是闪烁的.我需要你的帮助来解决这个问题.这是我的代码:

import java.awt.Color;

public class all extends JApplet implements Runnable {

    double x=0;
    double y=0;
    int m=0;
    int n=0;
    int f=30;
    int ?=0;
    Thread kinisi;
    JPanel panel;
    JFrame frame;
    private boolean running = false;
    private JTextField textField1;
    private JTextField textField2;
    Image backGround;
    JPanel panel_3;
    Image bf = createImage(m, n);
    private Graphics doubleg;
    private Image i;

    public void init() {
        this.setSize(800, 700);
    }

    public all() {
        getContentPane().setLayout(null);

        JButton btnNewButton = new JButton("Start");
        btnNewButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) { 
                String …

我想确保我明白一些事情.请确认这是否属实.

一个我声明一个线程,并在其中运行一些东西 - 从那一点开始的一切都将在该线程内运行,除非我明确地创建一个新线程.无论代码通过多少个类和方法 - 它都将保留在同一个线程中.

例如,假设我有一个完全在一个自定义JFrame内运行的应用程序.如果我希望整个应用程序在同一个线程内运行,我可以通过创建一个新线程,并在该线程的run()方法中实例化新的JFrame来实现.

这实际上是否会确保整个应用程序将在创建JFrame的线程内运行,除非我显式创建一个新线程并在该新线程内运行某些东西？

这是一个普遍的问题,但让我先谈谈Swing:

如果我希望整个Swing应用程序在EDT内运行(如果我错了请纠正我 - 正是我大部分时间都需要使用Swing),SwingUtilities.invokeLater()在main方法中使用一次就足够了,如下所示:

public static void main(String[]args){
    SwingUtilities.invokeLater( new Runnable(){
         JFrame frame = new CustomJFrame(); // where the entire application runs.
    } );
}

我有一个GUI应用程序,它有几个选项卡,每个选项卡都有一个JTable.我的UI类i在以下代码中处理来自Controller的事件,该代码在EDT上运行:

private void processAnalysisResult(AnalysisResult generatedValue) {
    LimitType limit = generatedValue.getMetric().getLimit();
    String limitName = limit.getName();
    int index = tabs.indexOfTab(limitName);
    Component component = tabs.getComponentAt(index);
    JScrollPane scrollPane = (JScrollPane) component;
    JTable table = (JTable) scrollPane.getViewport().getView();
    AnalysisResultTableModel model = (AnalysisResultTableModel) table.getModel();
    model.addRow(generatedValue);
    }
}

每秒有几千个新生成的结果,atm我把它降低到大约10k.即使使用相对较低的值,应用程序也会冻结大约10-20秒,从Jtable处理UI更新.插入每一行时,该addRow方法调用fireTableRowsInsertedmewthod,但这可能是那么慢吗？

编辑:这是处理事件的代码(从后台处理线程异步调用):

  controller.addAnalysisGenerationListener(new GeneratedValueListener<AnalysisResult>() {
        @Override
        public void valueGenerated(final GeneratedValueEvent<AnalysisResult> event) {
            processEDT(new Runnable() {
                @Override
                public void run() {
                    processAnalysisResult(event.getGeneratedValue());
                }
            });
        }
    });


private void processEDT(Runnable runnable) {
    if (EventQueue.isDispatchThread()) {
        runnable.run(); …

我有一个在EDT内执行的方法.它是这样的:

myMethod()
{
  System.out.prinln(SwingUtilities.isEventDispatchThread());

  for (int i = 0; i < 10; i++)
  {
   Thread.sleep(3000);
   someJPanel.remove(otherJPanel);
  }
}

我期望发生的事情:十个JPanels将逐一从他们的父母中删除,每次删除之间有三秒钟暂停...

实际发生了什么:在所有10个元素一次被移除之后,一切都冻结了30秒.

控制台中的行始终为true(SwingUtilities.isEventDispatchThread()).

由于我在EDT中做了这一切,为什么瞬间变化呢？为什么它等待方法首先达到它的结束？

我应该如何改变我的代码以实现删除之间的三秒延迟？

我是java的新手,它不是我的第一个编程语言.我实际上尝试编写下载所有文件的下载程序,直到服务器上的版本与客户端版本相同.

该计划运行良好,但这是我无法解决的问题.

如果我运行此代码:

private void updateContent()
{
    DownloadButton.setEnabled(false);
    SaveLocationButton.setEnabled(false);
    UpdateText.setText("Update to Version " + ServerVersionNumber + "...");
    UpdateText.setForeground(new Color(200, 150, 0, 255));
    ProgressText.setText("(1/2) Files will be downloaded");
    ProgressText.setForeground(new Color(200, 150, 0, 255));
    LoadingBar.setStringPainted(true);

    for(int i = 1; i < (ServerVersionNumber - LocalVersionNumber + 1); i++)
    {
        int CurrentUpdateFile = LocalVersionNumber + i;


        try 
        {
            URL FileURL = new URL(Host + CurrentUpdateFile + ".zip");

            try {
                FileURL.openConnection();


                InputStream reader = FileURL.openStream();
                FileOutputStream writer = new FileOutputStream(ContentSaveDirectory + CurrentUpdateFile + ".zip");

                byte[] …

http://www.youtube.com/watch?v=M0cNsmjK33E

我想使用Java Swing开发类似于以上链接的内容。我有排序方法，并且在重绘时做了，但是当我触发排序时，没有显示条形图对其进行缓慢排序，而是冻结并随后在数组完全排序后解冻。

我该如何解决？编辑：对不起，忘记了代码。它是一个非常简单的GUI。另一个用于排序的类对整个数组进行排序

public class SortGUI {
JFrame frame;
int frameWidth = 1000, frameHeight = 1000;
int panelWidth, panelHeight;
DrawPanel panel;
JPanel panel2;
JScrollPane scroll;
JViewport view;

static int[] S = new int[50000];

public static void main(String[] args) throws InterruptedException {
    SortGUI app = new SortGUI();
    initializeArray();        
    app.go(); 
}

public static void initializeArray()
{
         for (int i = 0; i < S.length; i++) {
     S[i] = (int) (Math.random() * 16581375);
     }
}

public void go() throws InterruptedException {
    //Frame …

我正在使用Java开发一个小游戏.我的应用程序有一个主JFrame,可以通过单击JButton创建另一个Window(游戏窗口).我已经单独测试了我的游戏窗口,一切都很好.

这是我的游戏窗口构造函数:

public GameWindow(final GameController controller)
{
    super("Boulder Dash Game");

    this.controller = controller;
    this.controller.registerObserver(getCurrentFrame()); 
    this.gamePanel = new GamePanel(controller);

    this.frameWidth = controller.getColumns() * 16;
    this.frameHeight = controller.getRows() * 16 + 76;

    getContentPane().add(gamePanel, BorderLayout.CENTER);

    setSize(frameWidth, frameHeight);
    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);
    controller.startGame();
}

controller.startGame()方法启动游戏循环.当我直接从我的主要开始这个窗口时,游戏循环工作正常.

现在,我想从我的主框架启动这个GameWindow框架.这是我的主框架中的代码:

playButton.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(final @Nullable ActionEvent e)
    {
        String selectedItem = (String) levelsComboBox.getSelectedItem();
        assert selectedItem != null;
        controller.lauchGame(selectedItem);
    }
});

controller.launchGame(String selectedItem)是一种用于加载游戏关卡并启动游戏窗口的方法.这是代码

public void lauchGame(final String levelQueried)
{
    assert levelQueried != null;
    Level level = LevelRepository.load(levelQueried); …