Hoe Callable gebruiken met ongeldig retourtype?

Ik werk aan een project waarin ik meerdere interfaces heb en twee implementatieklassen die deze twee interfaces moeten implementeren.

Stel dat mijn eerste interface is –

public Interface interfaceA {
    public void abc() throws Exception;
}

En de implementatie ervan is –

public class TestA implements interfaceA {
// abc method
}

Ik noem het zo –

TestA testA = new TestA();
testA.abc();

Mijn tweede interface is nu –

public Interface interfaceB {
    public void xyz() throws Exception;
}

En de implementatie ervan is –

public class TestB implements interfaceB {
// xyz method   
}

Ik noem het zo –

TestB testB = new TestB();
testB.xyz();

Probleemstelling:-

Mijn vraag is nu: is er een manier om deze twee implementatieklassen parallel uit te voeren? Ik wil het niet achter elkaar uitvoeren.

Betekent dit dat ik de implementatie TestAen TestBparallel wil uitvoeren? Is dit mogelijk?

Ik dacht eraan om hier Callable te gebruiken, maar ik weet niet zeker hoe ik hier Callable met ongeldig retourtype moet gebruiken –

Laten we de TestB-klasse als voorbeeld gebruiken:

public interface interfaceB {
    public void xyz() throws Exception;
}
public class TestB implements interfaceB, Callable<?>{
    @Override
    public void xyz() throws Exception
    {
        //do something
    }
    @Override
    public void call() throws Exception
    {
        xyz();
    }
}

Bovenstaande code geeft compilatiefout..

UPDATE:-

Het lijkt erop dat veel mensen voorstellen om Runnable te gebruiken in plaats van callable. Maar ik weet niet zeker hoe ik Runnable hier moet gebruiken, zodat ik TestA and TestBparallel kan uitvoeren.


Antwoord 1, autoriteit 100%

U kunt java.lang.Threadgebruiken voor parallelle uitvoering. In de meeste gevallen is het echter gemakkelijker om een ​​java.util.concurrent.ExecutorServicete gebruiken. De laatste biedt een methode om een ​​Callablein te dienen en retourneert een Futureom het resultaat later te krijgen (of te wachten op voltooiing).

Als testA.abc()en testB.xyz()parallel moeten worden uitgevoerd, gebruikt u de ExecutorServiceom de eerste uit te voeren in een aparte thread, terwijl de laatste wordt uitgevoerd in de originele thread. Dan wacht je op de voltooiing van de eerste voor synchronisatie.

ExecutorService executor = ... // e.g. Executors.newFixedThreadPool(4);
Future<Void> future = executor.submit(new Callable<Void>() {
    public Void call() throws Exception {
        testA.abc();
        return null;
    }
});
testB.xyz();
future.get(); // wait for completion of testA.abc()

Antwoord 2, autoriteit 4%

Waarom zou je een leegte nodig hebben om iets parallel te laten lopen? Ten eerste, als u de retourwaarde niet nodig heeft, kunt u eenvoudig nullretourneren.

Om iets parallel te maken, moet je threading/scheduling gebruiken. Ik zou persoonlijk aanraden om Callables te vermijden en in plaats daarvan Runnables te gebruiken (en hey, geen retourwaarde).


Antwoord 3, autoriteit 2%

Een kortere versie:

ExecutorService executor = ... // e.g. Executors.newFixedThreadPool(4);
Future<?> future = executor.submit(() -> testA.abc());
testB.xyz();
future.get(); // wait for completion of testA.abc()

Opgemerkt worden dat het een teken van een slecht patroon kan zijn om iets parallel te laten lopen en niets terug te geven 🙂

Ook, als u in een veeromgeving bent, kunt u gebruiken: https: // Spring.io/Guides/gs/async-method/

Other episodes