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

This article mainly introduces how to use Future class in Java language, which has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, let the editor take you to understand it.

Preface

In high-performance programming, concurrent programming has become a very important part. When the performance of single-core CPU has reached its limit, we can only use multiple cores to further improve the performance of the system, thus giving birth to concurrent programming.

As concurrent programming is more difficult and error-prone than serial programming, we need to learn from some excellent and mature design patterns of our predecessors to make our design more robust and perfect.

The Future pattern is one of the most widely used and extremely important design patterns.

Future Model in Life

To get a faster understanding of the Future pattern, let's look at a real-life example.

Scenario 1:

It was lunchtime, and the students were going to eat. Xiao Wang went downstairs and walked for 20 minutes. He came to KFC, ordered food, queued up, took 20 minutes to eat, and another 20 minutes to walk back to the company to continue to work, totaling one hour.

Scenario 2

It's lunchtime and the students are going to eat. Xiao Wang ordered a KFC takeout, and soon it got an order (although the order can't be eaten as a meal, but with the order, I'm afraid I won't be able to eat.) Then Xiao Wang can continue to work, 30 minutes later, takeout arrived, then Xiao Wang spent 10 minutes to eat, and then can continue to work, successfully rolled to the next door Xiao Wang.

Obviously, in these two scenes, Xiao Wang's working hours are more tight, especially those waiting in line can be done by takeout staff, so he can focus more on his own work. If you are smart, you should also realize that scenario 1 is a typical synchronous function call, while scenario 2 is a typical asynchronous call.

Another feature of the asynchronous call in scenario 2 is that it has a return value, which is our order. This order is very important, and with this order, we can get the result corresponding to the current call.

The order here is like Future in Future mode, this is a contract, a commitment. Although the order can not be eaten, but the order in hand, not afraid of no food, although Future is not the result we want, but with Future can get the results we want in the future.

Therefore, the Future pattern does a good job of dealing with asynchronous calls that require a return value.

Primary roles in Future mode

A typical Future pattern consists of the following parts:

Main: the system starts and calls Client to make a request

Client: returns the Data object, returns FutureData immediately, and starts the ClientThread thread assembly RealData

Data: the interface for returning data

FutureData:Future data, the construction is very fast, but a virtual data, need to assemble RealData, like an order

RealData: real data, its construction is relatively slow, like the KFC lunch in the above example.

The relationship between them is shown in the following figure:

Among them, it is worth noting that Data,RealData and FutureData. This is a set of typical agent patterns. Data interface represents external data, RealData represents real data, just like lunch, the cost of obtaining it is relatively high and takes a lot of time; relative FutureData as an agent of RealData, similar to an order / contract, through FutureData, you can obtain RealData in the future.

Therefore, the Future pattern is essentially a practical application of the agent pattern.

Implement a simple Future pattern

According to the above design, let's implement a simple proxy pattern.

The first is the Data interface, which represents data:

Public interface Data {public String getResult ();}

Then there is FutureData, which is the core of the whole Future pattern:

Public class FutureData implements Data {/ / Internal maintenance RealData protected RealData realdata = null; protected boolean isReady = false; public synchronized void setRealData (RealData realdata) {if (isReady) {return;} this.realdata = realdata; isReady = true; / / RealData has been injected, notify getResult () notifyAll () } / / will wait for RealData construction to complete public synchronized String getResult () {while (! isReady) {try {/ / wait until RealData is injected into wait () } catch (InterruptedException e) {}} / / the data you really need is obtained from RealData return realdata.result;}}

Here is the RealData:

Public class RealData implements Data {protected final String result; public RealData (String para) {StringBuffer sb=new StringBuffer (); / / assuming it's slow here, it's not easy to construct RealData result = sb.toString ();} public String getResult () {return result;}}

Then get Data from Client:

Public class Client {/ / this is an asynchronous method, and the returned Data interface is a Future public Data request (final String queryStr) {final FutureData future = new FutureData () New Thread () {public void run () {/ / RealData is slow to build, so RealData realdata = new RealData (queryStr) in a separate thread / / setRealData () will notify () the object future.setRealData (realdata) waiting on this future;}} .start (); / / FutureData will be returned immediately and will not wait for RealData to be constructed return future }}

The last Main function, which strands everything together:

Public static void main (String [] args) {Client client = new Client (); / / it will be returned immediately because you get FutureData instead of RealData Data data = client.request ("name"); System.out.println ("request completed") Try {/ / here you can replace the processing of other business logic with a sleep / / in the process of processing these business logic, the RealData is created, thus making full use of the wait time Thread.sleep (2000) } catch (InterruptedException e) {} / / use real data. If the data is not ready here, getResult () will wait for the data to be ready before returning System.out.println ("data =" + data.getResult ());}

This is the simplest implementation of the Future pattern, which, though simple, already contains the quintessence of the Future pattern. It is very important for you to understand the Future object within JDK.

Future mode in Java

The Future pattern is so commonly used that it has been fully implemented and supported within JDK. Next, let's take a look at the Future implementation within JDK:

First of all, there is a Future interface inside JDK, which is similar to the order mentioned earlier. Of course, as a complete commercial product, Future is more functional, providing a set of auxiliary methods in addition to the get () method to obtain real data.

Cancel (): if you wait too long, you can cancel the task directly.

IsCancelled (): has the task been cancelled?

IsDone (): has the task been completed?

Get (): there are two get () methods that represent infinite waits without arguments, or you can just wait for a given time

The following code demonstrates the use of this Future:

/ / Asynchronous operations can be performed with a thread pool ExecutorService executor = Executors.newFixedThreadPool (1); / / execute FutureTask, which is equivalent to client.request ("name") in the above example. / / call () execution Future future = executor.submit (new RealData ("name")) where the thread is opened for RealData; System.out.println ("request completed, data preparation") Try {/ / additional data operations can still be done here, where sleep is used instead of other business logic to process Thread.sleep (2000);} catch (InterruptedException e) {} / / if the call () method is not completed at this time, it will still wait for System.out.println ("data =" + future.get ())

The whole process is very simple, so let's take a look at what happened in executor.submit ():

Public Future submit (Callable task) {if (task = = null) throw new NullPointerException (); / / create a RunnableFuture based on the Callable object, which is actually FutureTask RunnableFuture ftask = newTaskFor (task); / / push ftask to the thread pool / / what is executed in the new thread is the run () method, which is given execute (ftask) in the following code / / return this Future, and you can get the result of execution return ftask;} protected RunnableFuture newTaskFor (Callable callable) {return new FutureTask (callable);} through this Future in the future.

The most important part is below. When FutureTask is executed separately as a thread, the result is saved to outcome and the state of the task is set. Here is the run () method of FutureTask:

The implementation of the result from FutureTask is as follows:

Public V get () throws InterruptedException, ExecutionException {int s = state; / / if it is not finished, wait, return to blocking the thread with the park () method / / at the same time, all waiting threads will queue in the waiters field of FutureTask for if (s = CANCELLED) throw new CancellationException (); throw new ExecutionException ((Throwable) x); higher-level version of Future mode-CompletableFuture

Although the Future mode is easy to use, there is also a problem, that is, after the task is submitted to the thread, the calling thread does not know when the task will be finished, and if the execution calls the get () method or the isDone () method, it may wait unnecessarily, so it is difficult to improve the throughput of the system.

In order to solve this problem, JDK has strengthened the Future mode and created a CompletableFuture, which can be understood as an upgraded version of the Future mode. Its biggest function is to provide a callback mechanism, which can automatically call back some subsequent processing after the task is completed, so that the whole program can completely remove the "result waiting".

Let's look at a simple example:

In this example, you first create an asynchronous call based on getPrice (), and then use the thenAccept () method to set up a subsequent operation, that is, the subsequent processing after the getPrice () execution is complete.

It is not difficult to see that CompletableFuture is more practical than the general Future, because it can automatically callback for the next operation after the successful execution of the Future, so the whole program will not be blocked in any way (that is, you do not have to wait around for the execution of the Future, but let the Future automatically tell you when the execution is successful).

Taking the above code as an example, all of CompletableFuture will have such amazing functionality, thanks entirely to the AsyncSupply class (created by the supplyAsync () method in the above code).

When AsyncSupply is executed, it looks like this:

Public void run () {CompletableFuture d; Supplier f; if ((d = dep)! = null & & (f = fn)! = null) {dep = null; fn = null If (d.result = = null) {try {/ / here is the asynchronous method you want to execute / / the result will be saved and put in the d.result field d.completeValue (f.get ()) } catch (Throwable ex) {d.completeThrowable (ex) }} / / if the execution is successful, the subsequent processing will be carried out. In this subsequent processing, the consumer / / in thenAccept () will be called, which is equivalent to the notification d.postComplete ();}} after the completion of Future.

Continue to look at d.postComplete (), where a series of subsequent operations will be called

Final void postComplete () {/ / omits part of the code, focusing on tryFire () / / in tryFire (), which really triggers the subsequent call, that is, the part of thenAccept () f = (d = h.tryFire (NESTED)) = = null? This: d;}} Thank you for reading this article carefully. I hope the article "how to use Future classes in Java language" shared by the editor will be helpful to you. At the same time, I hope you will support us and pay attention to the industry information channel. More related knowledge is waiting for you 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.