English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
并行流与串行流
并行流是将内容分成多个数据块，并使用不同的线程分别处理每个数据块的流。
java 8 中对并行操作进行了优化，我们可以轻松地对数据进行并行操作。Stream API 可以通过parallel（）和sequential（）显式地在并行流和顺序流之间进行切换。
了解 Fork/Join 框架
Fork/Join 框架：即在必要时，将一个大任务分解（fork）成若干个小任务（分解到不能再分解为止），然后将这些小任务运行的结果进行join汇总。
Fork/Join 框架与传统线程池的区别：
采用“工作窃取”模式(work-stealing):
当执行新任务时，它可以将其拆分成更小的任务执行，并将这些小任务添加到线程队列中，然后再从随机线程的队列中窃取一个任务并将其放入自己的队列中。
相对于常规的线程池实现，fork/join框架的优势在于其对包含的任务的处理方式。在常规的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程将处于等待状态。而在fork/im join-Framework, wenn ein Unterproblem aufgrund der Wartezeit auf die Fertigstellung eines anderen Unterproblems nicht fortgesetzt werden kann, sucht der Thread, der das Unterproblem bearbeitet, aktiv nach anderen noch nicht ausgeführten Unterproblemen, um sie auszuführen. Dies verringert die Wartezeit der Threads und verbessert die Leistung.
import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;
public class TestForkJoin {
public static void main(String[] xx){
}
private static void test1(){
Instant start=Instant.now();
ForkJoinPool pool=new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinCalculate(0L, 10000000000L);
long sum = pool.invoke(task);
System.out.println(sum);
Instant end=Instant.now();
System.out.println("Verbrauchte Zeit"+Duration.between(start, end).toMillis()+"ms");//Verbrauchte Zeit3409ms
}
private static void test2(){
Instant start=Instant.now();
Long sum = LongStream.rangeClosed(0L, 10000L)
.parallel();
.reduce(0,Long::sum);
System.out.println(sum);
Instant end=Instant.now();
System.out.println("Verbrauchte Zeit" + Duration.between(start, end).toMillis()+"ms");//Verbrauchte Zeit2418ms
}
}
class ForkJoinCalculate extends RecursiveTask<Long>{
private static final long serialVersionUID = 1234567890L;//Sequenznummer
private long start;
private long end;
private static final long THRESHOLD=2500000000L;//Schwellenwert
public ForkJoinCalculate(long start, long end) {
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
long length = end - start;
if(length <= THRESHOLD){
long sum = 0;
for(long i = start; i <= end; i++{
sum += i;
}
return sum;
} else {
long middle = (start+end);/2;
ForkJoinCalculate left = new ForkJoinCalculate(start, middle);
left.fork();
ForkJoinCalculate right = new ForkJoinCalculate(middle+1, end);
right.fork();
return left.join(); + right.join();
}
}
}
Klasse Optional
Klasse Optional< T>(java.util.Optional) ist eine Containerklasse, die einen vorhandenen oder nicht vorhandenen Wert repräsentiert.
Bisher wurde null verwendet, um einen nicht vorhandenen Wert zu kennzeichnen. Jetzt kann Optional diesen Begriff besser ausdrücken und Pfeilspitzenfehler vermeiden.
Häufig verwendete Methoden:
Optional.of(T t): Erzeugt ein Optional-Objekt
Optional.empty(): Erzeugt ein leeres Optional-Objekt
Optional.ofNullable(T t): Erzeugt ein Optional-Objekt, falls t nicht null ist, andernfalls erzeugt es ein leeres Objekt
isPresent(): Überprüft, ob ein Wert enthalten ist
orElse(T t): Gibt den Wert zurück, falls der aufgerufene Objekt einen Wert enthält, andernfalls gibt er t zurück
orElseGet(Supplier s): Gibt den Wert zurück, falls der aufgerufene Objekt einen Wert enthält, andernfalls gibt er den von s erhaltenen Wert zurück
map(Function f): Verarbeitet den Wert, falls vorhanden, und gibt den verarbeiteten Optional zurück, andernfalls gibt er Optional.empty() zurück
flatMap(Function mapper): Ähnlich wie map, erfordert der Rückgabewert eine Optional
public class OptionalTest1 {}}
public static void main(String[] args){
String s = new String("Ha");
// Optional<String> op = Optional.of(null);
//
// String s1 = op.get();
// System.out.println(s1);
// Optional<String> op1 = Optional.empty();
// String s1 = op1.get();
// System.out.println(s1);
Optional<String> op1 = Optional.ofNullable(null);
// System.out.println(op1.isPresent());
// System.out.println(op1.orElse(new String("Google")));
//System.out.println(op1.orElseGet(() -> new String("Ali")));
Optional<String> op2 = op1.map((x) -> x.toLowerCase());
String s2 = op2.get();
System.out.println(s2);
}
}
@Test
public void test5(){
Man man=new Man();
String name=getGodnessName(man);
System.out.println(name);
}
//Anforderung: Den Namen der Göttin in einem Manns Herzen ermitteln
public String getGodnessName(Man man){
if(man!=null){
Godness g=man.getGod();
if(g!=null){
return g.getName();
}
}
return "苍老师";
}
//Verwendung der Entity-Klasse Optional
@Test
public void test6(){
Optional<Godness> godness=Optional.ofNullable(new Godness("林志玲"));
Optional<NewMan> op=Optional.ofNullable(new NewMan(godness));
String name=getGodnessName2(op);
System.out.println(name);
}
public String getGodnessName2(Optional<NewMan> man){
return man.orElse(new NewMan())
.getGodness()
.orElse(new Godness("苍老师"))
.getName();
}
//Hinweis: Optional kann nicht serialisiert werden
public class NewMan {
private Optional<Godness> godness = Optional.empty();
private Godness god;
public Optional<Godness> getGod(){
return Optional.of(god);
}
public NewMan() {
}
public NewMan(Optional<Godness> godness) {
this.godness = godness;
}
public Optional<Godness> getGodness() {
return godness;
}
public void setGodness(Optional<Godness> godness) {
this.godness = godness;
}
@Override
public String toString() {
return "NewMan [godness=" + godness + "]";
}
}
Hier ist, was wir für Sie zusammengetragen haben, Java8Gesamter Inhalt der Erfahrungen mit den Frameworks forkjoin und optional. Bei Unklarheiten während des Lernens können Sie im folgenden Kommentarbereich diskutieren.
Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem jeweiligen Urheber. Der Inhalt wurde von Internetbenutzern selbstständig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht manuell bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Falls Sie verdächtige Inhalte bezüglich des Urheberrechts finden, senden Sie bitte eine E-Mail an: notice#w3Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem jeweiligen Urheber. Der Inhalt wurde von Internetbenutzern selbstständig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht manuell bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Falls Sie verdächtige Inhalte bezüglich des Urheberrechts finden, senden Sie bitte eine E-Mail an: notice#w