Calling a Background Thread in Swing

Question

First code:

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

public class cos {
   public static int a;

   private static JLabel labeler;

   // public static Runnable r1;

   private JFrame frame;

   /**
    * Launch the application.
    */
   public static void main(String[] args) {
      a = 0;
      EventQueue.invokeLater(new Runnable() {
         public void run() {
            try {
               cos window = new cos();
               window.frame.setVisible(true);
            } catch (Exception e) {
               e.printStackTrace();
            }
         }
      });

   }

   /**
    * Create the application.
    */
   public cos() {
      initialize();
   }

   /**
    * Initialize the contents of the frame.
    */
   public void initialize() {
      frame = new JFrame();
      frame.setBounds(100, 100, 205, 194);
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      JLabel lblTime = new JLabel("Time:");
      frame.getContentPane().add(lblTime, BorderLayout.WEST);

      final JLabel labeler = new JLabel("");
      frame.getContentPane().add(labeler, BorderLayout.CENTER);

      JButton btnNewButton = new JButton("New button");
      btnNewButton.addActionListener(new ActionListener() {
         Runnable r1 = new Runnable() {
            public void run() {
               while (a <= 10) {
                  a = a + 1;
                  labeler.setText(Integer.toString(a));
                  try {
                     Thread.sleep(1000);
                  } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                  }
               }

            }
         };

         public void actionPerformed(ActionEvent arg0) {
            Thread threder = new Thread(r1);
            threder.start();
            // liczniczek bla = new liczniczek();

         }
      });
      frame.getContentPane().add(btnNewButton, BorderLayout.SOUTH);

   }

   public void licznik() {
      while (a < 60) {
         a = a + 1;
         labeler.setText(Integer.toString(a));
         try {
            Thread.sleep(1000);
         } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
         }
      }
   }
}

And now my question. I wanna use code like this:

             Runnable r1 = new Runnable(){
                public void run(){
                           licznik();

                }
            };

But that doesen't work. What i must do to separate this code ? Sorry for my bad english

Sierran.

Answer 1

Look on GitHub under at https://github.com/greggwon/Ham. Look at the source code in https://github.com/greggwon/Ham/blob/master/SwingUtil/src/org/wonderly/swing/ComponentUpdateThread.java to see how I've packaged this whole detail into a single class which uses anonymous inner classes to do the work. It would be possible to change this to lambdas now, but I have not used Java in several years and thus haven't made that change.

    new ComponentUpdateThread( new Action[] { add, del, edit } ) {
        public void setup() {
            super.setup();
            list.setEnabled(false);
            list.clearSelection();
        }
        public Object construct() {
            try {
                Vector v = remote.getData();
                Collections.sort( v );
                return v;
            } catch( Exception ex ) {
                reportException(ex);
            }
            return null;
        }
        public void finished() {
            try {
                Vector v = (Vector)getValue();
                if( v != null ) list.setListData(v);
            } finally {
                super.finished();
                list.setEnabled(true);
                edit.setEnabled(false);
                del.setEnaled(false);
            }
        }
    }.start();

With this style of work, you can use final values from surrounding blocks or other class visible data to control various aspects of what happens before, during and after background thread execution.

I've change this code around over the years in various ways and there are other variations of this that exist.

The arguments to the ComponentUpdateThread constructor are controls/actions to be "disabled" while the background thread is running. Other enable/disable activities can be more literally embedded into the activities in setup() and finished() (which are run in the AWT event thread) before "construct" is run in the background thread.

Answer 2

never use Thread#sleep(int) during EDT, sure if is there only this thread then works correctly (with blockng EDT),

Runnable r1 = new Runnable(){
   public void run(){
       licznik();
   }
};

is wrong than same as you call plain licznik();, you have to wrap that this way

Runnable r1 = new Runnable(){
   public void run(){
       labeler.setText(Integer.toString(a));    
   }
};

but again without Thread#sleep(int), you have three choises

1) change Thread to the javax.swing.Timer

2) change Thread to the Runnable#Thread, there you can delaying with Thread#sleep(int), but output to the GUI must be

Runnable r1 = new Runnable(){
   public void run(){
       labeler.setText(Integer.toString(a));    
   }
};

3) use SwingWorker, where output is in the EDT and you can use Thread#sleep(int) too

example Thread#sleep(int) during EDT

put all together

EDIT

• don't use reserved words as class, method, variable, whatever Name in the Programing languages (meaning cos)

• your code works by implements all three options that I post here,

Answer 3

Runnable interface has no method licznik(). You can create class that implements Runnable with licznik() method.

Or if you do not need to reuse this method and use it just once, then the fastest way is to move its implementation inside new Runnable() block

         Runnable r1 = new Runnable(){
            public void run(){
                       this.licznik();

            }
            public void licznik(){
                while (a < 60){
                a = a + 1 ;
                labeler.setText(Integer.toString(a));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            }
        }
        }
        };

Answer 4

What do you mean "it doesn't work"? It works for me. How are you trying to use this code, and what errors or problems are you having when you run it? Myself, I'd use a SwingWorker though and I'd set the JLabel's text via the SwingWorker's publish/process method pair. To learn more on how to use this, please see this tutorial: Concurrency in Swing

Edit
Actually, an easier way to accomplish what you want is to not use threads or Runnables directly at all but to use a Swing Timer as they're built for just this case. For more on this, please check out the Swing Timer Tutorial

Answer 5

I gather that you want the function licznik() to run in a separate thread. You create a Runnable, but you have to do something more to make its run() method execute. There are a couple of ways to do this:

Runnable r1 = new Runnable(){
    public void run(){
        licznik();
    }
};
new Thread(r1).start();

or you can just subclass Thread directly:

Thread r1 = new Thread(){
    public void run(){
        licznik();
    }
};
r1.start();