This methods blocks until the worker is done and returns the result value of the JavaFX worker. - Java JavaFX

Java examples for JavaFX:Bindable Properties

Description

This methods blocks until the worker is done and returns the result value of the JavaFX worker.

Demo Code


/**//from ww w  . java  2  s.  c o  m
     * Copyright (c) 2011, 2014, Jonathan Giles, Johan Vos, Hendrik Ebbers
     * All rights reserved.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions are met:
     *     * Redistributions of source code must retain the above copyright
     * notice, this list of conditions and the following disclaimer.
     *     * Redistributions in binary form must reproduce the above copyright
     * notice, this list of conditions and the following disclaimer in the
     * documentation and/or other materials provided with the distribution.
     *     * Neither the name of DataFX, the website javafxdata.org, nor the
     * names of its contributors may be used to endorse or promote products
     * derived from this software without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
     * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     * DISCLAIMED. IN NO EVENT SHALL DataFX BE LIABLE FOR ANY
     * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
     * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     */
//package com.java2s;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;

import javafx.beans.property.BooleanProperty;
import javafx.beans.property.ReadOnlyBooleanProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.concurrent.Worker;

public class Main {
  /**
   * This methods blocks until the worker is done and returns the result value of
   * the worker. If the worker was canceled an exception will be thrown.
   *
   * @param worker
   *          The worker
   * @param <T>
   *          result type of the worker
   * @return the result
   * @throws InterruptedException
   *           if the worker was canceled
   */
  public static <T> T waitFor(Worker<T> worker) throws InterruptedException {
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    lock.lock();
    try {
      ReadOnlyBooleanProperty doneProperty = createIsDoneProperty(worker);
      if (doneProperty.get()) {
        return worker.getValue();
      } else {
        doneProperty.addListener(e -> {
          boolean locked = lock.tryLock();
          if (locked) {
            try {
              condition.signal();
            } finally {
              lock.unlock();
            }
          } else {
            throw new RuntimeException("Concurreny Error");
          }
        });
        condition.await();
        return worker.getValue();
      }
    } finally {
      lock.unlock();
    }
  }

  /**
   * Returns a property that defines the state of the given worker. Once the
   * worker is done the value of the property will be set to true
   * 
   * @param worker
   *          the worker
   * @return the property
   */
  public static ReadOnlyBooleanProperty createIsDoneProperty(Worker<?> worker) {
    final BooleanProperty property = new SimpleBooleanProperty();
    Consumer<Worker.State> stateChecker = (s) -> {
      if (s.equals(Worker.State.CANCELLED) || s.equals(Worker.State.FAILED) || s.equals(Worker.State.SUCCEEDED)) {
        property.setValue(true);
      } else {
        property.setValue(false);
      }
    };
    worker.stateProperty().addListener((o, oldValue, newValue) -> stateChecker.accept(newValue));
    stateChecker.accept(worker.getState());
    return property;

  }
}

Related Tutorials