Three ways to implement Java multithreading

Java Multi-threaded implementation of the main three kinds: inherit the thread class, implement Runnable interface, use Executorservice, callable, the future implementation has the result of multithreading. There are no return values for the first two methods after the thread has finished executing, only the last one with the return value.

1, inherit the thread class to realize multithreading
Methods of inheriting the thread class although I am listed as a multithreaded implementation, thread is essentially an instance of implementing the Runnable interface, which represents an instance of a thread, and the only way to start a thread is through the start () instance method of the thread class. The start () method is a native method that starts a new thread and executes the run () method. This way of implementing multithreading is simple, by extend thread directly through your own class, and by copying the run () method, you can start a new thread and execute your own defined run () method. For example:

[Java]View PlainCopy

1. Public class MyThread extends Thread {
2. 　　Public void Run () {
3. System.out.println ("Mythread.run ()");
4. }
5. }

Start the thread in the appropriate place as follows:

[Java]View PlainCopy

1. MyThread myThread1 = new MyThread ();
2. MyThread myThread2 = new MyThread ();
3. Mythread1.start ();
4. Mythread2.start ();

2, realize the Runnable interface way to realize multithreading
If your class already extends another class, you cannot directly extends the Thread, at which point you must implement a runnable interface, as follows:

[Java]View PlainCopy

1. Public class MyThread extends Otherclass implements Runnable {
2. 　　Public void Run () {
3. System.out.println ("Mythread.run ()");
4. }
5. }

In order to start mythread, you need to instantiate a thread first and pass in your own Mythread instance:

[Java]View PlainCopy

1. MyThread MyThread = new MyThread ();
2. Thread thread = new Thread (myThread);
3. Thread.Start ();

In fact, when a runnable target parameter is passed to thread, the thread's Run () method calls Target.run (), referencing the JDK source code:

[Java]View PlainCopy

1. Public void Run () {
2. 　　if (target! = null) {
3. Target.run ();
4. }
5. }

3, the use of Executorservice, callable, the future to achieve a return result of multi-threading
Executorservice, callable, future This object is actually a function class in the executor framework. To learn more about the accessible http://www.javaeye.com/topic/366591 of the executor framework, here is a detailed explanation of the framework. The thread that returns the result is a new feature introduced in JDK1.5, and it's really practical, and with this feature I don't have to go any further to get the return value, and it can be flawed even if it's done.
A task that can return a value must implement the callable interface, and similarly, a task that has no return value must runnable the interface. After performing the callable task, you can get a future object, call get on the object to get to the callable task returned object, and combined with the thread pool interface Executorservice can realize the legend has the return result of multithreading. Here is a complete example of a multithreaded test with return results, which can be used directly under JDK1.5. The code is as follows:

[Java]View PlainCopy

2. Import java.util.concurrent.*;
4. Import Java.util.Date;
6. Import java.util.List;
8. Import java.util.ArrayList;
12. /**
14. * Thread with return value
16. */
18. @SuppressWarnings ("unchecked")
20. Public class Test {
22. Public static void Main (string[] args) throws Executionexception,
24. interruptedexception {
26. System.out.println ("----program starts running----");
28. Date date1 = new Date ();
32. int tasksize = 5;
34. //Create a thread pool
36. Executorservice pool = Executors.newfixedthreadpool (tasksize);
38. //Create multiple tasks with return values
40. list<future> list = new arraylist<future> ();
42. For (int i = 0; i < tasksize; i++) {
44. Callable C = new mycallable (i + "");
46. //Perform tasks and get future objects
48. Future F = Pool.submit (c);
50. //System.out.println (">>>" + f.get (). toString ());
52. List.add (f);
54. }
56. //close thread pool
58. Pool.shutdown ();
62. //Get running results for all concurrent tasks
64. For (f:list) {
66. //Get the return value of the task from the future object and output it to the console
68. System.out.println (">>>" + f.get (). toString ());
70. }
74. Date Date2 = new Date ();
76. System.out.println ("----program ends running----, program run Time" "
78. + (Date2.gettime ()-date1.gettime ()) + "millisecond" ");
80. }
82. }
86. Class Mycallable implements Callable<object> {
88. Private String Tasknum;
92. Mycallable (String tasknum) {
94. this.tasknum = Tasknum;
96. }
100. Public Object call () throws Exception {
102. System.out.println (">>>" + tasknum + "task start");
104. Date DATETMP1 = new Date ();
106. Thread.Sleep (1000);
108. Date DATETMP2 = new Date ();
110. Long time = Datetmp2.gettime ()-datetmp1.gettime ();
112. System.out.println (">>>" + tasknum + "task termination");
114. return Tasknum + "task returns run result, current task time" "+" "+ " "milliseconds";
116. }
118. }

Code Description:
The executors class in the code above provides a series of factory methods for creating a first thread pool, and the returned thread pool implements the Executorservice interface.
public static Executorservice newfixedthreadpool (int nthreads)
Creates a thread pool of a fixed number of threads.
public static Executorservice Newcachedthreadpool ()
Creates a cacheable thread pool that calls execute to reuse previously constructed threads if the threads are available. If an existing thread is not available, a new thread is created and added to the pool. Terminates and removes from the cache those threads that have not been used for 60 seconds.
public static Executorservice Newsinglethreadexecutor ()
Create a single-threaded executor.
public static Scheduledexecutorservice newscheduledthreadpool (int corepoolsize)
Create a thread pool that supports timed and recurring task executions, which in most cases can be used to replace the timer class.

Executoreservice provides the submit () method, passing a callable, or runnable, back to the future. If the executor background thread pool has not completed the calculation of callable, this call returns the Get () method of the future object, blocking until the calculation is complete.

Reproduced in: http://www.cnblogs.com/yezhenhan/archive/2012/01/09/2317636.html

from:http://blog.csdn.net/aboy123/article/details/38307539

Three ways to implement Java multithreading