Shulou(Shulou.com)06/03 Report--

This article mainly explains "the introduction of three ways to realize JAVA multithreading". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn the "introduction of three ways to implement JAVA multithreading".

There are three main ways to realize JAVA multithreading: inheriting Thread class, implementing Runnable interface, and using ExecutorService, Callable and Future to realize multithreading with returned results. In the first two ways, the thread has no return value after execution, and only the last one has a return value.

1. Inherit the Thread class to implement multithreading

Although the method that inherits the Thread class is listed by me as a multithreaded implementation, Thread is essentially an instance of 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. Multithreading is easy to implement in this way. By directly extend Thread your own class and overriding the run () method, you can start a new thread and execute the self-defined run () method. For example:

Public class MyThread extends Thread {

Public void run () {

System.out.println ("MyThread.run ()")

}

}

Start the thread in the appropriate place as follows:

MyThread myThread1 = new MyThread ()

MyThread myThread2 = new MyThread ()

MyThread1.start ()

MyThread2.start ()

2. Implement Runnable interface to realize multithreading.

If your own class has already extends another class, you cannot directly extends Thread. At this point, you must implement a Runnable interface, as follows:

Public class MyThread extends OtherClass implements Runnable {

Public void run () {

System.out.println ("MyThread.run ()")

}

}

To start MyThread, you need to instantiate a Thread first and pass in your own MyThread instance:

MyThread myThread = new MyThread ()

Thread thread = new Thread (myThread)

Thread.start ()

In fact, when a Runnable target parameter is passed to Thread, the run () method of Thread calls target.run (), referring to the JDK source code:

Public void run () {

If (target! = null) {

Target.run ()

}

}

3. Use ExecutorService, Callable and Future to implement multithreading with returned results.

The objects ExecutorService, Callable and Future are actually functional classes in the Executor framework. The thread that returns the result is a new feature introduced in JDK1.5, which is really useful, with which I don't have to bother to get the return value, and even if I do, it may be full of loopholes.

Tasks that can return values must implement the Callable interface; similarly, tasks with no return values must have the Runnable interface. After executing the Callable task, you can get an object of Future, and call get on this object to get the Object returned by the Callable task. Combined with the thread pool interface ExecutorService, you can realize the legendary multithreading that returns results. A complete multithreaded test example with returned results is provided below, which has been verified under JDK1.5 that no problem can be used directly. The code is as follows:

Import java.util.concurrent.*

Import java.util.Date

Import java.util.List

Import java.util.ArrayList

/ * *

* Thread with return value

, /

@ SuppressWarnings ("unchecked")

Public class Test {

Public static void main (String [] args) throws ExecutionException

InterruptedException {

System.out.println ("- program starts running -")

Date date1 = new Date ()

Int taskSize = 5

/ / create a thread pool

ExecutorService pool = Executors.newFixedThreadPool (taskSize)

/ / create multiple tasks with return values

List list = new ArrayList ()

For (int I = 0; I

> > "+ f.get () .toString ()

List.add (f)

}

/ / close the thread pool

Pool.shutdown ()

/ / get the running results of all concurrent tasks

For (Future f: list) {

/ / get the return value of the task from the Future object and output it to the console

System.out.println (">" + f.get () .toString ())

}

Date date2 = new Date ()

System.out.println ("- the program ends running -, program running time ["

+ (date2.getTime ()-date1.getTime ()) + "millisecond]")

}

}

Class MyCallable implements Callable {

Private String taskNum

MyCallable (String taskNum) {

This.taskNum = taskNum

}

Public Object call () throws Exception {

System.out.println (">" + taskNum + "Task start")

Date dateTmp1 = new Date ()

Thread.sleep (1000)

Date dateTmp2 = new Date ()

Long time = dateTmp2.getTime ()-dateTmp1.getTime ()

System.out.println (">" + taskNum + "Task termination")

Return taskNum + "Task returns run result, current task time [" + time + "millisecond]"

}

}

Code description:

The Executors class in the above code provides a series of factory methods for creating thread pools, and the returned thread pools all implement the ExecutorService interface.

Public static ExecutorService newFixedThreadPool (int nThreads)

Create a thread pool with a fixed number of threads.

Public static ExecutorService newCachedThreadPool ()

Create a cacheable thread pool and calling execute will reuse the previously constructed thread (if the thread is available). If the existing thread is not available, create a new thread and add it to the pool. Terminates and removes threads from the cache 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 scheduled and periodic task execution, which in most cases can be used as an alternative to the Timer class.

ExecutoreService provides the submit () method, which passes a Callable, or Runnable, and returns Future. If the Executor background thread pool has not finished calculating the Callable, this calls the get () method that returns the Future object, blocking until the calculation is complete.

At this point, I believe you have a deeper understanding of the "introduction of three ways to implement JAVA multithreading". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.