1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * https://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.lang3.concurrent;
18
19 import java.util.Objects;
20 import java.util.concurrent.Callable;
21 import java.util.concurrent.ExecutorService;
22
23 /**
24 * A specialized {@link BackgroundInitializer} implementation that wraps a
25 * {@link Callable} object.
26 *
27 * <p>
28 * An instance of this class is initialized with a {@link Callable} object when
29 * it is constructed. The implementation of the {@link #initialize()} method
30 * defined in the super class delegates to this {@link Callable} so that the
31 * {@link Callable} is executed in the background thread.
32 * </p>
33 * <p>
34 * The {@link java.util.concurrent.Callable} interface is a standard mechanism
35 * of the JDK to define tasks to be executed by another thread. The {@code
36 * CallableBackgroundInitializer} class allows combining this standard interface
37 * with the background initializer API.
38 * </p>
39 * <p>
40 * Usage of this class is very similar to the default usage pattern of the
41 * {@link BackgroundInitializer} class: Just create an instance and provide the
42 * {@link Callable} object to be executed, then call the initializer's
43 * {@link #start()} method. This causes the {@link Callable} to be executed in
44 * another thread. When the results of the {@link Callable} are needed the
45 * initializer's {@link #get()} method can be called (which may block until
46 * background execution is complete). The following code fragment shows a
47 * typical usage example:
48 * </p>
49 *
50 * <pre>{@code
51 * // a Callable that performs a complex computation
52 * Callable<Integer> computationCallable = new MyComputationCallable();
53 * // setup the background initializer
54 * CallableBackgroundInitializer<Integer> initializer =
55 * new CallableBackgroundInitializer(computationCallable);
56 * initializer.start();
57 * // Now do some other things. Initialization runs in a parallel thread
58 * ...
59 * // Wait for the end of initialization and access the result
60 * Integer result = initializer.get();
61 * }
62 * </pre>
63 *
64 * @param <T> the type of the object managed by this initializer class
65 * @since 3.0
66 */
67 public class CallableBackgroundInitializer<T> extends BackgroundInitializer<T> {
68 /** The Callable to be executed. */
69 private final Callable<T> callable;
70
71 /**
72 * Creates a new instance of {@link CallableBackgroundInitializer} and sets
73 * the {@link Callable} to be executed in a background thread.
74 *
75 * @param call the {@link Callable} (must not be <strong>null</strong>).
76 * @throws IllegalArgumentException if the {@link Callable} is <strong>null</strong>.
77 */
78 public CallableBackgroundInitializer(final Callable<T> call) {
79 checkCallable(call);
80 callable = call;
81 }
82
83 /**
84 * Creates a new instance of {@link CallableBackgroundInitializer} and initializes it with the {@link Callable} to be executed in a background thread and
85 * the {@link ExecutorService} for managing the background execution.
86 *
87 * @param call the {@link Callable} (must not be <strong>null</strong>).
88 * @param exec an external {@link ExecutorService} to be used for task execution.
89 * @throws IllegalArgumentException if the {@link Callable} is <strong>null</strong>.
90 */
91 public CallableBackgroundInitializer(final Callable<T> call, final ExecutorService exec) {
92 super(exec);
93 checkCallable(call);
94 callable = call;
95 }
96
97 /**
98 * Tests the passed in {@link Callable} and throws an exception if it is undefined.
99 *
100 * @param callable the object to check.
101 * @throws IllegalArgumentException if the {@link Callable} is <strong>null</strong>.
102 */
103 private void checkCallable(final Callable<T> callable) {
104 Objects.requireNonNull(callable, "callable");
105 }
106
107 /**
108 * {@inheritDoc}
109 */
110 @Override
111 protected Exception getTypedException(final Exception e) {
112 //This Exception object will be used for type comparison in AbstractConcurrentInitializer.initialize but not thrown
113 return new Exception(e);
114 }
115
116 /**
117 * Performs initialization in a background thread. This implementation delegates to the {@link Callable} passed at construction time of this object.
118 *
119 * @return the result of the initialization.
120 * @throws Exception if an error occurs.
121 */
122 @Override
123 protected T initialize() throws Exception {
124 return callable.call();
125 }
126 }