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

This article is to share with you about how to achieve multithreading in Java, the editor thinks it is very practical, so I share it with you to learn. I hope you can get something after reading this article.

There are three Java multithreading implementations:

The three ways are explained by code examples:

1. Inherit the Thread class

Inherit Thread and override the run () method, and the start method in the Thread class will call the system method to execute the corresponding thread. In fact, Thread also implements Runable interface, as shown in the figure:

Code example:

Package com.hadoop.ljs.learning.thread;/** * functional description Thread Test Class the first way is inherited from the Thread class * @ author lujisen * @ date * @ param * @ return * / public class MyThread extends Thread {public static int sum=0 @ Override public void run () {while (true) {/ / print thread information System.out.println ("thread name:" + Thread.currentThread (). GetName () + "current sum value:" + (sum++)); try {sleep (5000);} catch (InterruptedException e) {e.printStackTrace () } public static void main (String [] args) {/ * create three threads * / MyThread thread1=new MyThread ("Thread 1"); MyThread thread2=new MyThread ("Thread 2"); MyThread thread3=new MyThread ("Thread 3")

Thread1.start (); thread2.start (); thread3.start ();} MyThread (String threadName) {Thread.currentThread () .setName (threadName);}}

2. Implement Runable interface

Implement the Runable interface and override the run () method. To start a thread, you must use the start () method of the Thread class, code example:

Package com.hadoop.ljs.learning.thread;import static java.lang.Thread.sleep;/* inherits Runnable interface * / public class MyThread2 implements Runnable {public static int sum=0; @ Override public void run () {while (true) {/ / print thread information System.out.println ("thread name:" + Thread.currentThread () .getName () + "current sum value:" + (sum++) Try {sleep (5000);} catch (InterruptedException e) {e.printStackTrace ();} public static void main (String [] args) {MyThread2 threadA=new MyThread2 (); Thread thread1=new Thread (threadA); thread1.setName ("thread A"); thread1.start () MyThread2 threadB=new MyThread2 (); Thread thread2=new Thread (threadB); thread2.setName ("thread B"); thread2.start (); MyThread2 threadC=new MyThread2 (); Thread thread3=new Thread (threadC); thread3.setName ("thread C"); thread3.start ();}}

3. Implement Callable interface

There are two problems with the above two ways, the first is that more exceptions cannot be thrown, and the second is that the thread cannot get the return value of the thread after execution. Then the following implementation method can meet our requirements. The Callable API is provided from Java5, which is an enhanced version of the Runnable interface. The Callable interface provides a call () method as the thread execution body, the call () method can have a return value, and the call () method can declare that an exception is thrown, but this method is complicated. The general steps are as follows:

1)。 Create a class that implements the Callable interface and implements the call method. This interface is similar to the Runnable interface, but more powerful than the Runnable interface, adding exceptions and return values.

2)。 Create a FutureTask and specify the Callable object as the thread task.

3)。 Create a thread and specify a thread task.

Code example:

Package com.hadoop.ljs.learning.thread

Import java.util.concurrent.Callable;import java.util.concurrent.FutureTask;/** * @ author: Created By lujisen * @ company ChinaUnicom Software JiNan * @ date: 2020-02-19 19:29 * @ version: v1.0 * @ description: com.hadoop.ljs.learning.thread * / / * create a class to implement the Callable interface * / public class MyThreadCallable1 implements Callable {/ / implement the call method. This interface is similar to the Runnable interface, but more powerful than the Runnable interface, with the exception and return value @ Override public Integer call () throws Exception {System.out.println ("implementing the call function to start the business logic."); Thread.sleep (5000); / * there is a return value * / return 1 } public static void main (String [] args) throws Exception {/ / create a FutureTask that specifies the Callable object as a thread task. FutureTask task = new FutureTask (new MyThreadCallable1 ()); / / start thread new Thread (task). Start (); / / here is after the thread starts, and before the result is returned, you can do another System.out.println ("after the thread starts, you can customize the business logic, because the above thread call function sleeps for 5 seconds.") / / get thread result Integer result = task.get (); System.out.println ("the result of asynchronous task execution in the main thread is" + result);}}

There are three ways to distinguish:

The first way to inherit Thread cannot inherit other classes, and the latter two can

Using the latter two ways, multiple threads can share a target;, so it is very suitable for multiple identical threads to deal with the same resource, thus the CPU, code and data can be separated to form a clear model, which better reflects the object-oriented idea.

When getting and setting the thread name, the first can use either this.setName () and this.getName () to set and get the current thread name, respectively, or Thread.currentThread (). GetName () and Thread.currentThread (). SetName (), and the latter two must use Thread.currentThread (). GetName ().

The method specified (overridden) by Callable is call (), and the method specified by Runnable is run (); the task of Callable can return a value after execution, while the task of Runnable cannot return a value; the call method can throw an exception, but the run method cannot

Run the Callable task to get a Future object that represents the result of the asynchronous calculation. It provides a way to check whether the calculation is complete, to wait for the calculation to complete, and to retrieve the results of the calculation. Through the Future object, you can know the execution of the task, cancel the execution of the task, and obtain the execution result.

The above is how to achieve multithreading in Java. The editor believes that there are some knowledge points that we may see or use in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

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.