并行流與串行流
并行流就是把一個內容分成多個數據塊，并用不同的線程分別處理每個數據塊的流。
java 8 中將并行進行了優(yōu)化，我們可以很容易的對數據進行并行操作。stream api 可以聲明性地通過 parallel（）與 sequential（）在并行流與順序流之間進行切換。
了解 fork/join 框架
fork/join 框架：就是在必要的情況下，將一個大任務，進形拆分（fork）成若干個小任務（拆到不可再拆時），再將一個個的小任務運行的結果進行join匯總。
fork/join 框架與傳統線程池的區(qū)別：
采用“工作竊取”模式(work-stealing):
當執(zhí)行新的任務時，它可以將其拆分成更小的任務執(zhí)行，并將小任務加到線程隊列中，然后再從一個隨機線程的隊列中偷一個并把它放在自己的隊列中。
相對于一般的線程池實現,fork/join框架的優(yōu)勢體現在對其中包含的任務的處理方式上.在一般的線程池中,如果一個線程正在執(zhí)行的任務由于某些原因無法繼續(xù)運行,那么該線程會處于等待狀態(tài).而在fork/join框架實現中,如果某個子問題由于等待另外一個子問題的完成而無法繼續(xù)運行.那么處理該子問題的線程會主動尋找其他尚未運行的子問題來執(zhí)行.這種方式減少了線程的等待時間,提高了性能。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
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("消耗時間"+duration.between(start, end).tomillis()+"ms");//消耗時間3409ms } 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("消耗時間" + duration.between(start, end).tomillis()+"ms");//消耗時間2418ms } }class forkjoincalculate extends recursivetask<long>{ private static final long serialversionuid = 1234567890l;//序列號 private long start; private long end; private static final long threshold=2500000000l;//臨界值 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(); } }} |
optional< t>類(java.util.optional) 是一個容器類，代表一個值存在或不存在。
原來用null表示一個值不存在，現在 optional可以更好的表達這個概念。并且可以避免空指針異常。
常用方法：
optional.of(t t) : 創(chuàng)建一個 optional 實例
optional.empty() : 創(chuàng)建一個空的 optional 實例
optional.ofnullable(t t):若 t 不為 null,創(chuàng)建 optional 實例,否則創(chuàng)建空實例
ispresent() : 判斷是否包含值
orelse(t t) : 如果調用對象包含值，返回該值，否則返回t
orelseget(supplier s) :如果調用對象包含值，返回該值，否則返回 s 獲取的值
map(function f): 如果有值對其處理，并返回處理后的optional，否則返回 optional.empty()
flatmap(function mapper):與 map 類似，要求返回值必須是optional
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
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); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
@test public void test5(){ man man=new man(); string name=getgodnessname(man); system.out.println(name); } //需求：獲取一個男人心中女神的名字 public string getgodnessname(man man){ if(man!=null){ godness g=man.getgod(); if(g!=null){ return g.getname(); } } return "蒼老師"; } //運用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(); }//注意：optional 不能被序列化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 + "]"; }} |
以上就是我們給大家整理的java8中forkjoin和optional框架使用心得的全部內容，大家在學習的時候如果還有任何不明白的地方可以在下方的留言區(qū)討論。
原文鏈接：https://my.oschina.net/u/3746673/blog/1594197
