Question

我使用从jframe扩展的类，它有一个按钮（我在我的程序中使用它）

我想在我的程序中运行jframe时整个程序暂停

直到我按下按钮。

我该怎么做

在c ++中getch()执行此操作。

我想要这样的功能。

Answer 1

Pausing Execution with Sleep，虽然我怀疑这是你想要使用的机制。因此，正如其他人所建议的那样，我相信你需要实现wait-notify逻辑。这是一个非常人为的例子：

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

@SuppressWarnings("serial")
public class PanelWithButton extends JPanel
{
    // Field members
    private AtomicBoolean paused;
    private JTextArea textArea;
    private JButton button;
    private Thread threadObject;

    /**
     * Constructor
     */
    public PanelWithButton()
    {
        paused = new AtomicBoolean(false);
        textArea = new JTextArea(5, 30);
        button = new JButton();

        initComponents();
    }

    /**
     * Initializes components
     */
    public void initComponents()
    {
        // Construct components
        textArea.setLineWrap(true);
        textArea.setWrapStyleWord(true);
        add( new JScrollPane(textArea));
        button.setPreferredSize(new Dimension(100, 100));
        button.setText("Pause");
        button.addActionListener(new ButtonListener());
        add(button);

        // Runnable that continually writes to text area
        Runnable runnable = new Runnable()
        {
            @Override
            public void run() 
            {
                while(true)
                {
                    for(int i = 0; i < Integer.MAX_VALUE; i++)
                    {
                        if(paused.get())
                        {
                            synchronized(threadObject)
                            {
                                // Pause
                                try 
                                {
                                    threadObject.wait();
                                } 
                                catch (InterruptedException e) 
                                {
                                }
                            }
                        }

                        // Write to text area
                        textArea.append(Integer.toString(i) + ", ");


                        // Sleep
                        try 
                        {
                            Thread.sleep(500);
                        } 
                        catch (InterruptedException e) 
                        {
                        }
                    }
                }
            }
        };
        threadObject = new Thread(runnable);
        threadObject.start();
    }

    @Override
    public Dimension getPreferredSize()
    {
        return new Dimension(400, 200);
    }

    /**
     * Button action listener
     * @author meherts
     *
     */
    class ButtonListener implements ActionListener
    {
        @Override
        public void actionPerformed(ActionEvent evt) 
        {
            if(!paused.get())
            {
                button.setText("Start");
                paused.set(true);
            }
            else
            {
                button.setText("Pause");
                paused.set(false);

                // Resume
                synchronized(threadObject)
                {
                    threadObject.notify();
                }
            }
        }
    }
}

这是你的主要课程：

 import javax.swing.JFrame;
    import javax.swing.SwingUtilities;


    public class MainClass 
    {
        /**
         * Main method of this application
         */
        public static void main(final String[] arg)
        {
            SwingUtilities.invokeLater(new Runnable()
            {
                public void run()
                {
                    JFrame frame = new JFrame();
                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    frame.add(new PanelWithButton());
                    frame.pack();
                    frame.setVisible(true);
                    frame.setLocationRelativeTo(null);
                }
            });
        }
    }

正如您所看到的，此示例应用程序将不断写入文本区域，直到您单击“暂停”按钮，然后恢复您需要单击同一按钮，该按钮现在将显示为“开始”。< / p>

Answer 2

这个答案完全取决于我是否正确理解您的问题，如果您想要更好的答案，请提供更多信息。这是：

在循环场景中暂停

 boolean paused;
 while(true ) {
   if(paused)
   {
     Thread.sleep(1000); // or do whatever you want in the paused state
   } else {
     doTask1
     doTask2
     doTask3
   }
 }

主题：您还可以将这些任务放在单独的线程中而不是GUI线程上，这通常是您长时间运行的操作。

暂停线程很容易。只需在其上调用suspend（）即可。当您要取消暂停呼叫resume（）时。然而，这些方法很危险，已被弃用。通过检查暂停标志，更好或更安全的方式与上面的方法类似。这是我在我的片段中躺着的一个简短示例。不能完全记住我在哪里得到它：

// Create and start the thread
MyThread thread = new MyThread();
thread.start();

while (true) {
    // Do work

    // Pause the thread
    synchronized (thread) {
        thread.pleaseWait = true;
    }

    // Do work

    // Resume the thread
    synchronized (thread) {
        thread.pleaseWait = false;
        thread.notify();
    }

    // Do work
}

class MyThread extends Thread {
    boolean pleaseWait = false;

    // This method is called when the thread runs
    public void run() {
        while (true) {
            // Do work

            // Check if should wait
            synchronized (this) {
                while (pleaseWait) {
                    try {
                        wait();
                    } catch (Exception e) {
                    }
                }
            }

            // Do work
        }
    }
}    // Create and start the thread
MyThread thread = new MyThread();
thread.start();

while (true) {
    // Do work

    // Pause the thread
    synchronized (thread) {
        thread.pleaseWait = true;
    }

    // Do work

    // Resume the thread
    synchronized (thread) {
        thread.pleaseWait = false;
        thread.notify();
    }

    // Do work
}

class MyThread extends Thread {
    boolean pleaseWait = false;

    // This method is called when the thread runs
    public void run() {
        while (true) {
            // Do work

            // Check if should wait
            synchronized (this) {
                while (pleaseWait) {
                    try {
                        wait();
                    } catch (Exception e) {
                    }
                }
            }

            // Do work
        }
    }
}

希望这有帮助

Answer 3

尝试我的java暂停按钮：

package drawFramePackage;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JFrame;
import javax.swing.Timer;
public class Milliseconds2 implements ActionListener, MouseListener{
    JFrame j;
    Timer t;
    Integer onesAndZeros, time, time2, placeHolder2;
    Boolean hasFired;
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Milliseconds2();
    }
    public Milliseconds2(){
        j = new JFrame();
        j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        j.setSize(new Dimension(300, 300));
        j.setVisible(true);
        j.addMouseListener(this);
        onesAndZeros = new Integer(0);
        time = new Integer(0);
        time2 = new Integer(0);
        placeHolder2 = new Integer(0);
        hasFired = new Boolean(true);
        t = new Timer(2400, this);
        time = (int) System.currentTimeMillis();
        t.start();
    }
    @Override
    public void mouseClicked(MouseEvent e) {
        // TODO Auto-generated method stub
        if (onesAndZeros.equals(0)){
            t.stop();
            if (hasFired){
                time2 = t.getDelay() - ((int) System.currentTimeMillis() - time);
            }
            else{
                time2 -= (int) System.currentTimeMillis() - placeHolder2;
            }
            if (hasFired){
                hasFired = false;
            }
            onesAndZeros = -1;
        }
        if (onesAndZeros.equals(1)){
            //System.out.println(time2);
            t.setInitialDelay(time2);
            t.start();
            placeHolder2 = (int) System.currentTimeMillis();
            onesAndZeros = 0;
        }
        if (onesAndZeros.equals(-1)){
            onesAndZeros = 1;
        }
    }
    @Override
    public void mousePressed(MouseEvent e) {
        // TODO Auto-generated method stub

    }
    @Override
    public void mouseReleased(MouseEvent e) {
        // TODO Auto-generated method stub

    }
    @Override
    public void mouseEntered(MouseEvent e) {
        // TODO Auto-generated method stub

    }
    @Override
    public void mouseExited(MouseEvent e) {
        // TODO Auto-generated method stub

    }
    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub
        time = (int) System.currentTimeMillis();
        hasFired = true;
        System.out.println("Message");
    }
}

Answer 4

冻结你的主线程将有效地冻结整个程序，并可能导致操作系统认为应用程序已崩溃，不太确定如果我错了，请纠正我。您可以尝试隐藏/禁用控件，并在用户单击按钮时再次启用它们。

Answer 5

暂停时你没有说出你的意思。你的应用程序在做什么？

根据经验，您无法暂停UI应用。用户界面应用程序从消息处理循环运行。消息进入，消息被调度，循环等待另一条消息。应用程序仍然需要处理用户单击按钮，调整窗口大小，关闭应用程序等操作，以便此循环连续运行。

如果您希望应用程序在阻止用户执行操作的意义上“暂停”，只需将用户不想要的任何按钮或菜单变灰。

如果你的应用程序在后台运行一个帖子，并希望它在你恢复之前暂停该操作，你可以很容易地这样做。

MyThread mythread = new MyThread();

// Main thread
void pause() {
  mythread.pause = true;
}

void resume() {
  synchronized (mythread) {
    mythread.pause = false;
    mythread.notify();
  }
}


class MyThread extends Thread {
  public boolean pause = false;

  public void run() {
    while (someCondition) {
      synchronized (this) {
        if (pause) {
          wait();
        }
      }
      doSomething();
    }
  }
}

也可以使用Thread.suspend（），Thread.resume（）来完成类似的操作，但这些本质上很危险，因为你不知道挂起它时线程在哪里。它可能有一个文件打开，通过套接字发送消息的一半等。在任何循环控制你的线程中进行测试允许你在安全的时候暂停。

Answer 6

UI使用消息驱动机制执行任务。

如果您的UI中有一个按钮，并且您希望在按下该按钮时运行某些按钮，则应该在按钮上添加ActionListener对象。按下按钮后，它会触发ActionListener对象以执行任务，例如：

button.addActionListener(new ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        // do something
    }
});

如果您想在按暂停按钮时停止某些操作，则您将无需Thread。这比前一种情况更复杂。

如何暂停程序直到按下按钮？

6 个答案: