Wie können wir eine Callable in eine runnable

Question

konvertieren Ich habe eine Klasse, die die aufrufbare Schnittstelle implementiert. Ich möchte eine Aufgabe für die Klasse mithilfe der Methode "scheduledExecutorService" planen. Allerdings benötigt scheduleAtFixedRate ein lauffähiges Objekt als einen Befehl, den es einplanen kann.

Daher brauche ich eine Möglichkeit, in der ich ein Callable zu einem Runnable konvertieren kann. Ich habe versucht, einfach zu Casting, aber das funktioniert nicht.

SAMPLE CODE:

package org.study.threading.executorDemo; 

import java.util.concurrent.Callable; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ScheduledExecutorService; 
import java.util.concurrent.TimeUnit; 

class ScheduledExecutionTest implements Callable<String> { 

    @Override 
    public String call() throws Exception { 
     // TODO Auto-generated method stub 
     System.out.println("inside the call method"); 
     return null; 
    } 

} 
public class ScheduledExecution { 
    public static void main(String[] args) { 
     ScheduledExecutorService sec = Executors.newScheduledThreadPool(10); 
     sec.scheduleAtFixedRate(new ScheduledExecutionTest(), 5, 2, TimeUnit.SECONDS); 
    } 
} 

Answer 1

FutureTask task1 = new FutureTask(Callable<V> callable) 

Nun ist diese task1 ist runnable weil:

1. class FutureTask<V> implements RunnableFuture<V>
2. RunnableFuture<V> extends Runnable, Future<V>

So von oben zwei Beziehungen, task1 runnable und kann im Inneren eingesetzt werden Executor.execute(Runnable) Methode

Answer 2

Warum nicht so etwas wie verwenden:

final Callable<YourType> callable = ...; // Initialize Callable 

    Runnable callableAsRunnable =() -> { 
    try { 
     callable.call(); 
    } catch (Exception e) { 
     // Handle the exception locally or throw a RuntimeException 
    } 
    }; 

Answer 3

Unter der Annahme, brauchen Sie nicht wirklich die Callable etwas Nützliches zurückzukehren, können Sie eine aufrufbare als ein Runnable

wickeln

Runnable run = new Runnable() { 
    public void run() { 
     try { 
      Object o = callable.call(); 
      System.out.println("Returned " + o); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 
}; 

oder in Java 8

Runnable run =() -> { 
    try { 
     Object o = callable.call(); 
     System.out.println("Returned " + o); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
}; 

Dies ist ziemlich chaotisch, aber es klingt wie die Callable sollte in erster Linie ein Runnable gewesen sein, und Sie würden dies nicht tun müssen.

Answer 4

Verwenden Sie zukünftige Aufgabe, es implementiert sowohl Runnable und aufrufbar, Sie müssen nicht viel Code ändern.

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/FutureTask.html