April 5, 2013

Java 8 နှင့် Project Lambda

မကြာခင် Java 8 ထွက်တော့ပါမည်။ jdk 8 ကိုလည်း Java.net မှ ဒေါင်းလုဒ်လုပ်ယူနိုင်ခဲ့သည်မှာ ကြာပြီဖြစ်၏။ ကျွှန်တော်လည်း တစ်ခေါက်မှ စမ်းမသုံးရသေးပါ။ ဒီရက်ပိုင်းအတွင်း အလုပ်ကိစ္စတွေ များနေသောကြောင့် လုံးဝကို မစမ်းရသေးပါ။ မရေးကြည့်ပဲနဲ့တော့ မနေနိုင်တဲ့ ကျွှန်တော်ဟာ ဒီအပတ်မှာ Java 8 ကို စမ်းကြည့်ရန် ဆုံးဖြတ်ခဲ့ပြီး၊ Myanmar Java User တွင် ဘလောဂ်ခေါင်းစဉ်တစ်ခုကို စတင်ရေးသားခဲ့ပါသည်။

Java 8 ၏ ဖြစ်တည်ပုံ

Java 8 သည်ယနေ့တိုင်ထွက်ခဲ့သော အခြားသော ဗားရှင်းများနှင့်အနည်းငယ်ထူးခြားပါသည်။ အကြောင်းမှာ Java 8 ၏ New Featureအတော်များများသည် ယခင် Java 7 တွင်ပါဝင်ရန် ရည်ရွယ်ထားခဲ့ပြီးမှ ချန်ထားခဲ့သော Feature များ ဖြစ်ကြ၏။

ပြန်ကြည့်မည်ဆိုလျှင် Java 6 ထွက်ပေါ်ပြီးသည့်နောက် Sum Microsystem အား Oracle မှဝယ်ယူခဲ့ပြီး Java 7 ထွက်ပေါ်ရန်မှာ အချိန်အတော်လေး ယူခဲ့ရပါသည်။ အထူးသဖြင့် Project Lambda နှင့် Project Jigsaw တို့သည် အတော်လေးကို လမ်းပျောက်ခဲ့ရပါသည်။

ထိုအချိန်တွင် Java ၏ Spec Leader တစ်ဦးဖြစ်သော Mr. Mark Reinhold မှ အကြံနှစ်ခုကို တင်သွင်းလာခဲ့ပါသည်။ ပဋ္ဌမ အစီအစဉ်မှာ Project Lambda နှင့် Project Jigsaw တို့အား ပြီးအောင်စောင့်၍ Java 7 အား Release လုပ်မည့်အစီအစဉ်ဖြစ်၏။ ဒုတိယအစီအစဉ်မှာ Project Lambda နှင့် Project Jigsaw တို့အား ပြီးအောင်ရေး၍ Java 7 အား Release လုပ်မည့် အစီအစဉ်ဖြစ်၏။ ဤကဲ့သို့ ဒုတိယအစီအစဉ်အား စောင့်ရင်းဖြင့် Java 7 ၏ Release Time မှာ အတော်လေးကို နှောင့်နေးခဲ့ရပါသည်။

နောက်ဆုံးတွင် ပဋ္ဌမအစီအစဉ်အား ရွေးချယ်ခဲ့ပြီး ၇လပိုင်း ၂၀၁၁ခုနှစ်တွင် Java 7 အား Release လုပ်ခဲ့ပါသည်။ ထိုတင်မက Project Lambda နှင့် Project Jigsaw အပြင် JSR 308 Annotations on Java Types နှင့် JSR 310 Date and Time API တို့ကိုလည်း Java 8 အထိချန်ရစ်ထားခဲ့ပါတော့သည်။

ထို့ကြောင့် Java 8 သည် Java 7 ၏ ကျန်ရစ်ခဲ့သော Features များနှင့် အချို့သော New Features များဖြင့် ဖွဲ့စည်းထားခြင်းပင် ဖြစ်ပါသည်။ ထို့အပြင် Project Jigsaw မှာ Java 8 တွင် မမှီနိုင်ပဲ Java 9 အထိ Sleep ဖြစ်ခဲ့ရပါသေးသည်။

Open JDK ၏ Java 8 Project တွင် ဖော်ပြထားသော Java 8 ၏ အဓိက Features များမှာ အောက်ပါအတိုင်းဖြစ်ပါသည်။
・Project Lambda
・JavaFX
・Annotations on Java Types
・Date and Time API
・Nashorn JavaScript Engine
・Compact Profiles
・HotRockit

နောက်ဆုံးတွင် Release လုပ်မည့် Features များအား JSR 337 Java SE 8 Release Contents တွင် ဖော်ပြသွားမည် ဖြစ်ပါသည်။ ဤဘလောဂ်တွင်တော့ Java 8 ၏ အဓိက Feature တစ်ခုဖြစ်သော Project Lambda မှစတင်၍ လေ့လာသွားပါမည်။

Project Lambda

Project Lambda သည် Multi Core ပတ်ဝင်းကျင်ပေါ်ရှိ Programming အား ပံ့ပိုးရန်ရည်ရွယ်၍ ဖွဲ့စည်းခဲ့သော Project တစ်ခုဖြစ်ပါသည်။ အဓိကကျသည်မှာ Lambda ပုံစံ ရေးသားနည်း ပင်ဖြစ်၏။ Project Lambda မပေါ်ခင်က Java ဘာသာရပ်တွင် Closure အား ထည့်သွင်းရန် ကြံစည်ခဲ့ကြသေး၏။ သို့ရာတွင် Project Lambda ထွက်ပေါ်လာခဲ့ပြီး Closure လည်း Java နှင့် ဝေးခဲ့ရခြင်း ဖြစ်ပါသည်။

နောက်ပိုင်းတွင် Project Lambda သည် Multi Core Programming များ၏ Parallel Processing များအား လွယ်ကူစွာရေးသားနိုင်ရန် ရည်ရွယ်၍ ရေးသားလာခဲ့ကြပါသည်။ Project Lambda မှ ရေးသားနေသော Lambda ပုံစံ ရေးသားနည်းသည် Closure နှင့် ဆင်တူသော ရေးသားနည်း ဖြစ်သော်လည်း Parallel Processing အား လွယ်ကူစွာရေးသာနိုင်ရန် ရည်ရွယ်၍ ရေးသားထားပါသည်။ ထိုရည်ရွယ်ချက်ကြောင့် Lambda ရေးသားနည်းတွင် ဘာသာရပ်ပိုင်းဆိုင်ရာ ပြောင်းလည်းမှု့များအား အနည်းဆုံးဖြစ်အောင် ကြိုးစား ရေးသားခဲ့ပါသည်။

နမှုနာအားဖြင့် ExecutorService Interface အား အသုံးပြု၍ Runnable Interface အား Asynchronous Process အဖြစ် အလုပ်လုပ်စေရာတွင် အောက်ပါအတိုင်း ရေးသားရမည် ဖြစ်သည်။
    ExecutorService service = ...;

    service.submit(new Runnable() {
        @Override
        public void run() {
            // Asynchronous processing metthod
            doSomething();
        }
    });
Asynchronous Process တစ်ခုကို ရေးသားသည်မှာ မှန်သော်လည်း Anonymous Class အား ရေးသားနေရသောကြောင့် မလိုအပ်ပဲ ရှည်ရှားနေတတ်၏။ Lambda ရေးသားနည်း ဖြင့် ရေးသားပါက အောက်ပါအတိုင်းတွေ့ရမည် ဖြစ်ပါသည်။
    ExecutorService service = ...;
        
    service.submit(() -> doSomething());
Lambda ရေးသားနည်း အသေးစိတ်အား နောက်ပိုင်းတွင် ဖော်ပြမည် ဖြစ်သော်လည်း ကြည့်ရုံဖြင့် ရှင်းလင်းစွာရေးသားနိုင်သည်ကို သိရှိနိုင်မည် ဖြစ်ပါသည်။

Lambda ရေးသားနည်းသည် Interface အား Implementလုပ်ထားသော Anonymous Class ၏ Instance ပြုလုပ်ခြင်းအား လွယ်ကူစွာရေးသားနိုင်ခြင်းသာ ဖြစ်သည်ဟု ထင်မြင်ဖွယ်ရာရှိပါသည်။ သို့ရာတွင် မည်သည့် Interface မျိုးကိုမဆို Lambda နည်းဖြင့် ရေးသားနိုင်ခြင်း တော့မဟုတ်ပါ။ Lambda နည်းဖြင့် ရေးသားနိုင်သော Interface အား Functional Interface ဟု ခေါ်ဆိုပါသည်။

Functional Interface သည်လည်း Project Lambda ဖြင့် ရေးသားလာခဲ့သော ရေးသားနည်း တစ်ခုဖြစ်ပါသည်။ ထို့ကြောင့် Lambda ပုံစံအား မလေ့လာခင် Functional Interface အား လေ့လာသွားပါမည်။

Functional Interface

Functional Interface ဆိုသည်မှာ Implement လုပ်ရန် Method တစ်ခုသာပါဝင်သော Interface များကို ဆိုလိုပါသည်။ ဥပမာအားဖြင့် Runnable နှင့် Callable Interface များသည် Method တစ်ခုတည်းသာရှိသောကြောင့် Functional Interface များဖြစ်ကြ၏။ Runnable Interface တွင် run Method အား ၎င်း Callable Interface တွင် call Method ကို၎င်း ရေးသားရုံသာဖြစ်၏။

အတိအကျပြောရမည် ဆိုလျှင် Functional Interface တွင် Method တစ်ခုသာ ရေးသား နိုင်သည် မဟုတ်ပါ။ နောက်ပိုင်းအခန်းများတွင် ဆက်လက်ဖော်ပြသွားမည် ဖြစ်သော်လည်း Project Lambda တွင် Interface တွင် Method များအား Default Implement လုပ်လာနိုင်ပါသည်။ ထို့ကြောင့် Method အများအား ရေးသားရန်လိုအပ်သော Interface ဖြစ်သော်လည်း Default Implement လုပ်ထားပါက Functional Interface အဖြစ်အသုံးပြုနိုင်မည် ဖြစ်ပါသည်။

Functional Interface ဖြစ်ကြောင်း ဖော်ပြလိုပါက @FunctionalInterface ဟု ဖြည့်စွက်ရေးသားနိုင်ပါသည်။ ဤကဲ့သို့ရေးသားထားခြင်းဖြင့် ထို Interface သည် Functional Interface ဖြစ်ကြောင်း Compiler မှ သိရှိနိုင်မည် ဖြစ်သည်။ ဤကဲ့သို့ရေးသားထားပါက ကွန်ပိုင်းပြုလုပ်စဉ် ကွန်ပိုင်လာမှ Functional Interface တစ်ခုဖြစ်ကြောင်း စီစစ်သွားမည် ဖြစ်ပါသည်။

Lambda နည်း

Lambda နည်းသည် အထက်ဖော်ပြပါ Functional Interface များအား Anonymous Class များဖြင့် Implements လုပ်ရာတွင် လွယ်ကူစွာရေးသားနိုင်ပါသည်။  သို့ရာတွင် သတိပြုရန်မှာ Lipsဘာသာရပ်တွင်အသုံးပြုထားသော ရေးသားပုံနှင့်အနည်းငယ် ကွာခြားခြင်း ဖြစ်ပါသည်။

Lambda နည်း မှာ အောက်ပါအတိုင်း ရေးသားနိုင်ပါသည်။
    (Arguments) -> { Expressions }

ကွင်းငယ်အတွင်းတွင် Functional Interface ၏ ဖြည့်စွက်ရေးသားရန် လိုသည့် လုပ်ဆောင်ချက်၏ ပါရာမီတာအား ရေးသားရန်လိုအပ်ပြီး၊ လက်သည်းကွင်းအတွင်းတွင်မှာမူ လုပ်ဆောင်ချက်၏ Process များအား ရေးသားရန်လိုအပ်ပါသည်။

လက်တွေ့ရေးသားမည်ဆိုပါက အောက်ပါအတိုင်း ရေးသားနိုင်မည် ဖြစ်ပါသည်။
    Runnable runnable = () -> { doSomething(); };
    Callable<String> callable = () -> { return "Hello, World!"; };
    ActionListener listener = (ActionEvent e) -> 
        { label.setText("Hello, World!"); };
    Comparator<Integer> comparator = (Integer x, Integer y) -> 
        { return x - y; };
ရေးသားလိုသော လော့ဂျစ်သည် တစ်ကြောင်းတည်းဆိုပါက လက်သည်းကွင်းအား မရေးပဲ နေနိုင်သလို၊ return ကိုလည်း မရေးပဲ ဖော်ပြနိုင်ပါသည်။ တဖန် ပါရာမီတာကိုလည်းမရေးပဲနေနိုင်သလို၊ တစ်ခုတည်းဆိုပါက ကွင်းငယ်ကိုလည်း မရေးပဲဖော်ပြနိုင်ပါသေးသည်။

ထို့ကြောင့် အထက်ပါ ရေးသားပုံအား အောက်ပါအတိုင်းလည်း ရေးသားနိုင်ပါသေး၏။
    Runnable runnable = () -> doSomething();
    Callable<String> callable = () -> "Hello, World!";
    ActionListener listener = e -> label.setText("Hello, World!");
    Comparator<Integer> comparator = (x, y) -> x - y;
အထက်ဖော်ပြပါများအား ကြည့်ခြင်းအားဖြင့် Lambda နည်းသည် Anonymous Class ရေးသားနည်းများအား လွယ်ကူစွာဖော်ပြနိုင်ကြောင်း ကို တွေ့ရပါသည်။ သို့ရာတွင် Lambda နည်းအား အသုံးပြုရုံဆိုပါက Anonymous Class များအား လွယ်ကူစွာဖော်ပြနိုင်ရုံထက်ပိုမည် မဟုတ်သေးပေ။ Parallel Process များအား အသုံးပြုလိုပါက အခြားသော နည်းပညာရပ်များလည်း လိုအပ်နေပါသေးသည်။ Project Lambda သည် Collection များအား Parallel Process များတွင် လွယ်ကူစွာအသုံးပြုနိုင်ရန် API များကိုလည်း ပြင်ဆင်ထားပါသေးသည်။

နောက်အခန်းများတွင် Lambda Project မှ ပံ့ပိုးထားသော အဆိုပါ API များအကြောင်းကို ဆက်လက်ဖော်ပြသွားပါဦးမည်။


ကိုးကား

http://www.computerworld.jp/topics/3366/206684

လေးစားစွာဖြင့်
မင်းလွင်
 

No comments:

Post a Comment