The most common difference is: When you extend Thread class, you can’t extend any other class which you require. (As you know, Java does not allow inheriting more than one class). When you implement Runnable, you can save a space for your class to extend any other class in future or now. However, the significant … Read more
The reason is “backwards compatibility”. The Thread class originated in Java 1.0 … or earlier. In those days, Java didn’t have inner classes, and so there wasn’t a light-weight way to implement a Runnable instance. If you look at old threading examples and tutorials from that era, it is common to see classes that extend … Read more
The UserInterface can only be updated by the UI Thread. You need a Handler, to post to the UI Thread: private void startTimerThread() { Handler handler = new Handler(); Runnable runnable = new Runnable() { private long startTime = System.currentTimeMillis(); public void run() { while (gameState == GameState.Playing) { try { Thread.sleep(1000); } catch (InterruptedException … Read more
Synchronizing the run() method of a Runnable is completely pointless unless you want to share the Runnable among multiple threads and you want to sequentialize the execution of those threads. Which is basically a contradiction in terms. There is in theory another much more complicated scenario in which you might want to synchronize the run() … Read more
Simply a class that implements Runnable with constructor that accepts the parameter can do, public class MyRunnable implements Runnable { private Data data; public MyRunnable(Data _data) { this.data = _data; } @override public void run() { … } } You can just create an instance of the Runnable class with parameterized constructor. MyRunnable obj = … Read more
It appears to me that removeCallbacks(..) only stops pending messages (Runnables). If your runnable has already started, then there’s no stopping it (at least not this way). Alternatively, you can extend the Runnable class and give it some kind of kill switch like this: public class MyRunnable implements Runnable { private boolean killMe = false; … Read more
Instead implement your own thread.kill() mechanism, using existing API provided by the SDK. Manage your thread creation within a threadpool, and use Future.cancel() to kill the running thread: ExecutorService executorService = Executors.newSingleThreadExecutor(); Runnable longRunningTask = new Runnable(); // submit task to threadpool: Future longRunningTaskFuture = executorService.submit(longRunningTask); … … // At some point in the future, … Read more
As the others have mentioned, using the Thread class is the correct way. However, you should also look in to using Javas Executors framework to handle running threads. Executors.newSingleThreadExecutor().execute(new Runnable() { @Override public void run() { // code in here } }); Of course, just using Thread directly is fine. But it is generally advised … Read more
I would say there is little difference between using a Message vs a Runnable. It’ll mostly boil down to personal preference. Why? Looking at the source code you’ll find that posting a Runnable uses the same exact messaging mechanism. It simply attaches the Runnable to a Message and sends that. 4.4.2 Source Code public final … Read more
AsyncTask is a convenience class for doing some work on a new thread and use the results on the thread from which it got called (usually the UI thread) when finished. It’s just a wrapper which uses a couple of runnables but handles all the intricacies of creating the thread and handling messaging between the … Read more