What are the ways to implement multithreading in Java?-javaTutorial-php.cn

Preface

There are four main ways to implement Java multi-threading:

① Inherit the Thread class and implement the Runnable interface

② Implement the Callable interface and create it through the FutureTask wrapper Thread thread

③ Use ExecutorService and Callable

④ Future to implement multi-threading with return results

The first two methods have no return value after the thread is executed, and the latter two methods The kind has a return value.

1. Four ways to implement multi-threading

1. Inherit the Thread class to create threads

The Thread class is essentially an instance that implements the Runnable interface, representing a thread. Example. Using the start() instance method of the Thread class is the only way to start a thread. A new thread executing the run() method is started by calling the start() method, which is a native method. It is very simple to implement multi-threading in this way. By directly extending Thread through your own class and overriding the run() method, you can start a new thread and execute your own defined run() method. For example:

public class MyThread extends Thread { 　　public void run() { 　　 System.out.println("MyThread.run()"); 　　} } MyThread myThread1 = new MyThread(); MyThread myThread2 = new MyThread(); myThread1.start(); myThread2.start();

Copy after login

2. Implement the Runnable interface to create a thread

If your class has extended another class, you cannot directly extend Thread. At this time, you can implement a Runnable interface, as follows:

public class MyThread extends OtherClass implements Runnable { 　　public void run() { 　　 System.out.println("MyThread.run()"); 　　} }

Copy after login

In order 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();

Copy after login

In fact, when a Runnable target parameter is passed to Thread, Thread's run( ) method will call target.run(), refer to the JDK source code:

public void run() { 　　if (target != null) { 　　 target.run(); 　　} }

Copy after login

3. Implement the Callable interface

Create a Thread thread through the FutureTask wrapper

Callable interface (There is only one method) defined as follows:

public interface Callable { V call（） throws Exception; } public class SomeCallable extends OtherClass implements Callable { @Override public V call() throws Exception { // TODO Auto-generated method stub return null; } }

Copy after login

Callable oneCallable = new SomeCallable(); //由Callable创建一个FutureTask对象： FutureTask oneTask = new FutureTask(oneCallable); //注释：FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口。 //由FutureTask创建一个Thread对象： Thread oneThread = new Thread(oneTask); oneThread.start(); //至此，一个线程就创建完成了。

Copy after login

4. Implement a thread that returns a result

Use ExecutorService, Callable, and Future to implement a thread that returns a result

ExecutorService, The three interfaces Callable and Future actually belong to the Executor framework. In JDK1.5, threads that return results are introduced as a new feature, so you no longer need to go through trouble to obtain the return value. And even if you implement it yourself, it may be full of loopholes.

Tasks that can return values must implement the Callable interface. Similarly, tasks that do not return a value must implement the Runnable interface.

After executing the Callable task, you can obtain a Future object. By calling get on the object, you can obtain the Object returned by the Callable task.

Note: The get method is blocking, that is: the thread returns no result, and the get method will wait forever.

Combined with the thread pool interface ExecutorService, the legendary multi-threading with returned results can be realized.

It has been verified under JDK1.5 and there is no problem. You can directly use the multi-threaded test example with returned results provided below. The code is as follows:

import java.util.concurrent.*; import java.util.Date; import java.util.List; import java.util.ArrayList; /** * 有返回值的线程 */ @SuppressWarnings("unchecked") public class Test { public static void main(String[] args) throws ExecutionException, InterruptedException { System.out.println("----程序开始运行----"); Date date1 = new Date(); int taskSize = 5; // 创建一个线程池 ExecutorService pool = Executors.newFixedThreadPool(taskSize); // 创建多个有返回值的任务 List list = new ArrayList(); for (int i = 0; i < taskSize; i++) { Callable c = new MyCallable(i + " "); // 执行任务并获取Future对象 Future f = pool.submit(c); // System.out.println(">>>" + f.get().toString()); list.add(f); } // 关闭线程池 pool.shutdown(); // 获取所有并发任务的运行结果 for (Future f : list) { // 从Future对象上获取任务的返回值，并输出到控制台 System.out.println(">>>" + f.get().toString()); } Date date2 = new Date(); System.out.println("----程序结束运行----，程序运行时间【" + (date2.getTime() - date1.getTime()) + "毫秒】"); } } class MyCallable implements Callable