As we all know,a thread is a separate process on your computer.you can run multiple threads all at the same time.
multi-threaded code has the disadvantage of becoming quite complex very quickly,although java has some great classes for dealing
with multithreading and simplifying it.
Today we will just look at creating threads,along with using anonymous classes to simplify(or some would say,complexify)your code.
there are two methods to Creating Threads in Java
the first way is to extend the Thread class, override the run() method with the code you want to execute,
then create a new object from your class and call start().
the second method is to pass an implementation of the Runnable interface to the constructor of Thread,
then call start().
we will look at both of the method in turn.
1.Extending the Thread Class
the sample code ad bellow:
public class Worker extends Thread {
@Override
public void run() {
// Loop for ten iterations.
for(int i=0; i<10; i++) {
System.out.println(i + " looping ...");
// Sleep for a while
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// Interrupted exception will occur if
// the Worker object's interrupt() method
// is called. interrupt() is inherited
// from the Thread class.
break;
}
}
}
}
As shown above, we have create a Worker class that extends Thread. And override the run() Method and put some code
in it. The code just loops repeatedly and outputs a method.
we've also used a static method of the thread class,sleep().
note:if you use sleep,you should have to catch InterruptedException.
In the code below,we create two worker class and call their inherited start() methods, both run at the same time,not one after the other
public class Application {
public static void main(String[] args) {
Worker worker1 = new Worker();
worker1.start();
Worker worker2 = new Worker();
worker2.start();
// You can call interrupt() if you want
// to interrupt a thread. The thread itself
// decides how to handle interrupts.
// worker1.interrupt();
}
}
screenshot as below:
0 looping ... 0 looping ... 1 looping ... 1 looping ... 2 looping ... 2 looping ... 3 looping ... 3 looping ... 4 looping ... 4 looping ... 5 looping ... 5 looping ... 6 looping ... 6 looping ... 7 looping ... 7 looping ... 8 looping ... 8 looping ... 9 looping ... 9 looping ...the start() method, inherited from the parent Thread class, creates a new thread and runs whatever code is in run() in the new thread.
if not use the threads:
public class Application {
public static void main(String[] args) {
Worker worker1 = new Worker();
worker1.run();
Worker worker2 = new Worker();
worker2.run();
// You can call interrupt() if you want
// to interrupt a thread. The thread itself
// decides how to handle interrupts.
// worker1.interrupt();
}
}
result as below:
0 looping ... 1 looping ... 2 looping ... 3 looping ... 4 looping ... 5 looping ... 6 looping ... 7 looping ... 8 looping ... 9 looping ... 0 looping ... 1 looping ... 2 looping ... 3 looping ... 4 looping ... 5 looping ... 6 looping ... 7 looping ... 8 looping ... 9 looping ...above code doesn't use multithreading, take twice as long to run.
2.passing code to Thread Directly
the second method of starting a thread is to put the code you want to run in the run method of a class that implements the Runnable interface, then pass it to
the constructor of a thread class
the code below does exactly that;we've put the code all in one file to make it easier to follow.
class CodeRunner implements Runnable {
@Override
public void run() {
// Loop for ten iterations.
for(int i=0; i<10; i++) {
System.out.println(i + " looping ...");
// Sleep for a while
try {
Thread.sleep(200);
} catch (InterruptedException e) {
break;
}
}
}
}
public class Application {
public static void main(String[] args) {
CodeRunner runner = new CodeRunner();
Thread thread = new Thread(runner);
thread.start();
}
}
result:
0 looping ... 1 looping ... 2 looping ... 3 looping ... 4 looping ... 5 looping ... 6 looping ... 7 looping ... 8 looping ... 9 looping ...we can simplify this code by calling new directly on our coderunner class,right where we create the thread.
Thread thread = new Thread(new CodeRunner()); thread.start();
3.Quick and Dirty Thread using Anonymous Class
in fact we can make this code even terser by creating a new intance of Runnable,sortof,directly in the Thread constructor.
Actually,we can't create a new intance of Runnable because it's an interface; so we can't do the follow:
// Won't work Thread thread = new Thread(new Runnable()); thread.start();
but we can get this to work if we add in some curly brackets and implement the missing run() method in them.
// This works
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
}
});
thread.start();
of course, to get this code to do anything, we have to add some actual code to run.
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for(int i=0; i<10; i++) {
System.out.println(i + " looping ...");
}
}
});
thread.start();
0 looping ... 1 looping ... 2 looping ... 3 looping ... 4 looping ... 5 looping ... 6 looping ... 7 looping ... 8 looping ... 9 looping ...finally,we can make the code ecen more terse, if a little more cryptic,by not bothering to declare a variable to hold the thread class, and then
just calling the stat() method on it directly.
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0; i<10; i++) {
System.out.println(i + " looping ...");
}
}
}).start();
here just to make the code a bit clearer.
if you are also interest in linux and android embed system,please connection with us in QQ group:139761394
