All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.commons.lang3.concurrent.CallableBackgroundInitializer Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.lang3.concurrent;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;

import org.apache.commons.lang3.Validate;

/**
 * 

* A specialized {@link BackgroundInitializer} implementation that wraps a * {@code Callable} object. *

*

* An instance of this class is initialized with a {@code Callable} object when * it is constructed. The implementation of the {@link #initialize()} method * defined in the super class delegates to this {@code Callable} so that the * {@code Callable} is executed in the background thread. *

*

* The {@code java.util.concurrent.Callable} interface is a standard mechanism * of the JDK to define tasks to be executed by another thread. The {@code * CallableBackgroundInitializer} class allows combining this standard interface * with the background initializer API. *

*

* Usage of this class is very similar to the default usage pattern of the * {@link BackgroundInitializer} class: Just create an instance and provide the * {@code Callable} object to be executed, then call the initializer's * {@link #start()} method. This causes the {@code Callable} to be executed in * another thread. When the results of the {@code Callable} are needed the * initializer's {@link #get()} method can be called (which may block until * background execution is complete). The following code fragment shows a * typical usage example: *

* *
 * // a Callable that performs a complex computation
 * Callable<Integer> computationCallable = new MyComputationCallable();
 * // setup the background initializer
 * CallableBackgroundInitializer<Integer> initializer =
 *     new CallableBackgroundInitializer(computationCallable);
 * initializer.start();
 * // Now do some other things. Initialization runs in a parallel thread
 * ...
 * // Wait for the end of initialization and access the result
 * Integer result = initializer.get();
 * 
* * * @since 3.0 * @param the type of the object managed by this initializer class */ public class CallableBackgroundInitializer extends BackgroundInitializer { /** The Callable to be executed. */ private final Callable callable; /** * Creates a new instance of {@code CallableBackgroundInitializer} and sets * the {@code Callable} to be executed in a background thread. * * @param call the {@code Callable} (must not be null) * @throws IllegalArgumentException if the {@code Callable} is null */ public CallableBackgroundInitializer(final Callable call) { checkCallable(call); callable = call; } /** * Creates a new instance of {@code CallableBackgroundInitializer} and * initializes it with the {@code Callable} to be executed in a background * thread and the {@code ExecutorService} for managing the background * execution. * * @param call the {@code Callable} (must not be null) * @param exec an external {@code ExecutorService} to be used for task * execution * @throws IllegalArgumentException if the {@code Callable} is null */ public CallableBackgroundInitializer(final Callable call, final ExecutorService exec) { super(exec); checkCallable(call); callable = call; } /** * Performs initialization in a background thread. This implementation * delegates to the {@code Callable} passed at construction time of this * object. * * @return the result of the initialization * @throws Exception if an error occurs */ @Override protected T initialize() throws Exception { return callable.call(); } /** * Tests the passed in {@code Callable} and throws an exception if it is * undefined. * * @param call the object to check * @throws IllegalArgumentException if the {@code Callable} is null */ private void checkCallable(final Callable call) { Validate.isTrue(call != null, "Callable must not be null!"); } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy