Avec du fil d'expression Lambda

J'ai une erreur à la ligne 42 et 43 : Thread t1=new Thread(()->prod.test()); , Thread t2=new Thread(()->cons.test()); exception non Gérée du type InterruptedException . Si j'essaie de quickfix il a créé le try catch avec un catch Exception, il aura la même erreur et va essayer de le résoudre de la même manière continue de l'entourer avec des try catch.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
interface Predicate {
public void test() throws InterruptedException;
}
class MyClass {
int num = 0;
Lock lock = new ReentrantLock();
public void produce() throws InterruptedException {
lock.lock();
for (int i = 0; i < 1000; i++) {
num++;
Thread.sleep(1);
}
lock.unlock();
}
public void consume() throws InterruptedException {
lock.lock();
for (int i = 0; i < 1000; i++) {
num--;
Thread.sleep(1);
}
lock.unlock();
}
public int getNum() {
return num;
}
}
public class Main00 {
public static void main(String[] args) throws InterruptedException {
MyClass c = new MyClass();
Predicate prod = c::produce;
Predicate cons = c::consume;
Thread t1 = new Thread(() -> prod.test());
Thread t2 = new Thread(() -> cons.test());
long start = System.currentTimeMillis();
t1.start();
t2.start();
t1.join();
t2.join();
long end = System.currentTimeMillis();
System.out.println("time taken " + (end - start) + " num = "
+ c.getNum());
}
}
InformationsquelleAutor T4l0n | 2015-07-14
  1. 15

    Vous avez créé une interface fonctionnelle Predicate dont la méthode est déclarée à jeter un InterruptedException, qui est un checked exception. Cependant, vous appelez test() dans le corps d'une expression lambda comme paramètre de le Thread constructeur qui prend un Exécutable, dont run() méthode n'est pas déclarée à jeter tout vérifié exceptions. Donc, parce que l'exception n'est pas pris dans le corps, une erreur de compilation se produit.

    Il peut d'ailleurs être source de confusion pour le nom de votre propre interface Predicate, en raison de la intégré dans l'interface fonctionnelle java.util.fonction.Prédicat dont la méthode renvoie une boolean.

    Parce que run() ne pouvez pas lancer une Exception, vous devez catch l'exception et le gérer. Vous pouvez enregistrer l'exception et sa trace de la pile. Vous pouvez envelopper l'exception dans un RuntimeException. De toute façon, la capture faisant l'objet d'une exception permettra le code à compiler. Exemple:

    Thread t1 = new Thread(() -> {
try {
prod.test();
} catch (InterruptedException e) {
//handle: log or throw in a wrapped RuntimeException
throw new RuntimeException("InterruptedException caught in lambda", e);
}
});
    InformationsquelleAutor rgettman
  2. 3

    Comme @rgettman dit, le nom Predicate est malheureux... de toute façon, vous pouvez prendre avantage de default méthodes en Java:

    interface PredicateButPleaseChangeMyName {
void test() throws InterruptedException;
default void tryTest() {
try {
this.test();
} catch (InterruptedException e) {
//handle e (log or wrap in a RuntimeException)
}
}
}

    Ensuite, dans votre méthode principale, il suffit de créer les threads en appelant le défaut tryTest() méthode:

    Thread t1 = new Thread(() -> prod.tryTest());
Thread t2 = new Thread(() -> cons.tryTest());
    InformationsquelleAutor Federico Peralta Schaffner
  3. 3

    Si vous envisagez sur l'exécution d'une méthode unique, sans arguments, vous pouvez remplacer le lambda avec une méthode de référence.

    Par exemple:

    Thread t = new Thread(() -> {
foo();
});

    peut être plus succinctement exprimée en 

    Thread t = new Thread(this::foo);
    InformationsquelleAutor MeetTitan