การใช้งาน Async ในภาษา Java แบบง่ายๆ พร้อมตัวอย่าง

หัวข้อ: เส้นทางสู่การเขียนโปรแกรมแบบไม่รอคอยด้วย Async ใน Java

การเขียนโปรแกรมในปัจจุบันไม่ได้มุ่งเน้นเพียงแค่การให้คำสั่งและรับผลลัพธ์เท่านั้น แต่ยังรวมถึงการเพิ่มประสิทธิภาพในการทำงานโดยการลดเวลาที่ระบบหรือแอปพลิเคชันต้องรอคอย (wait time) เพราะทุกวินาทีที่เสียไปนั้นมีค่าอย่างมากในโลกธุรกิจที่ต้องแข่งขันสูง ในภาษา Java หนึ่งในเทคนิคที่ช่วยในเรื่องนี้คือการใช้งานการเขียนโค้ดแบบ Async (Asynchronous) ที่ช่วยให้สามารถดำเนินงานหลายๆ อย่างพร้อมกันโดยไม่ต้องรอให้แต่ละงานเสร็จสิ้นลง ในบทความนี้เราจะมาเรียนรู้วิธีการใช้งาน Async ใน Java และดูตัวอย่างโค้ดในสถานการณ์จริงไปพร้อมๆ กัน

ความหมายของ Async ในโลกของ Java

การทำงานแบบ Asynchronous หมายความว่าเมื่อเราทำการเรียก method หรือฟังก์ชันใดๆ ใน Java จะไม่ทำให้การทำงานของโปรแกรมหยุดชะงัก แต่การทำงานนั้นๆ จะเกิดขึ้นบน Thread อื่นที่ทำงานแยกต่างหาก ซึ่งทำให้การทำงานหลักสามารถดำเนินไปได้โดยไม่ต้องรอให้งานข้างเคียงทำเสร็จสิ้น

ในระบบที่มีการจัดการเวลาอย่างเข้มงวด การใช้ Async นี้จะทำให้โปรแกรมสามารถทำการคำนวณ, ดึงข้อมูลจากฐานข้อมูล, หรือติดต่อกับซิสเต็มอื่นๆ ได้โดยที่ยังคงรักษาประสบการณ์ผู้ใช้ที่ยอดเยี่ยมไว้ได้ แม้ในสถานการณ์ที่ต้องรอการตอบสนองจากระบบ โดยการใช้ Future, CompletableFuture, หรือ Reactive Streams ใน Java เราสามารถถ่ายทอดความซับซ้อนเหล่านี้ให้ง่ายต่อการเข้าใจและใช้งานได้

ตัวอย่างโค้ด Async ใน Java

ตัวอย่างที่ 1: การใช้ CompletableFuture

 import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class AsyncExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            // สมมุติเป็นการดึงข้อมูลจากฐานข้อมูลที่ใช้เวลานาน
            System.out.println("Fetching data...");
            try {
                Thread.sleep(2000); // หลับไป 2 วินาที
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Data fetched");
        });

        // ทำงานอื่นๆ ในเวลาเดียวกัน
        System.out.println("Doing other things while data is being fetched...");

        // รอจนกว่าข้อมูลจะถูกดึงมาครบ
        future.get();

        System.out.println("All tasks completed.");
    }
}

ในตัวอย่างนี้เราสร้าง CompletableFuture ที่จะทำการดึงข้อมูลและในขณะเดียวกันโค้ดที่อยู่นอกการทำงานของ CompletableFuture ก็สามารถทำงานต่อไปได้โดยไม่ต้องรอ

ตัวอย่างที่ 2: การใช้ Future

 import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Future<String> future = executorService.submit(() -> {
            // สมมุติเป็นการทำ API call ที่อาจจะใช้เวลา
            Thread.sleep(3000); // หลับไป 3 วินาที
            return "Result from lengthy operation";
        });

        // ทำงานอื่นๆ ขณะรอการประมวลผล
        System.out.println("Doing something else while waiting for the result...");

        // รับค่าผลลัพธ์เมื่อมันพร้อม
        String result = future.get(); // รอจนกว่า Future จะมีผลลัพธ์
        System.out.println("Result: " + result);

        executorService.shutdown();
    }
}

ในตัวอย่างที่ 2 เราได้ใช้ Future เพื่อดำเนินการที่ใช้เวลายาวนานบนเธรดหนึ่ง และรอการจบการทำงานจาก Future ด้วยการเรียก `future.get()` ซึ่งจะ block จนกว่าผลลัพธ์จะพร้อม

ตัวอย่างที่ 3: Reactive Streams ด้วย Flow API (เพิ่มเติมใน Java 9 ขึ้นไป)

 import java.util.concurrent.SubmissionPublisher;
import java.util.concurrent.Flow.*;

public class ReactiveStreamExample {
    public static void main(String[] args) throws InterruptedException {
        try (SubmissionPublisher<String> publisher = new SubmissionPublisher<>()) {
            publisher.subscribe(new Subscriber<>() {
                private Subscription subscription;

                @Override
                public void onSubscribe(Subscription subscription) {
                    this.subscription = subscription;
                    subscription.request(1);
                }

                @Override
                public void onNext(String item) {
                    System.out.println("Received item: " + item);
                    subscription.request(1); // ขอรับข้อมูลต่อไป
                }

                @Override
                public void onError(Throwable throwable) {
                    throwable.printStackTrace();
                }

                @Override
                public void onComplete() {
                    System.out.println("Completed");
                }
            });

            // สร้างและส่งข้อมูลแบบ Asynchronous
            System.out.println("Publishing items...");
            publisher.submit("Item 1");
            publisher.submit("Item 2");
            publisher.submit("Item 3");

            // เราสามารถทำงานอื่นๆ ได้ในขณะที่publishing process กำลังดำเนินการ
            System.out.println("Doing other tasks...");

            // ประมวลผลเพียงพอแล้วดำเนินการต่อ
            Thread.sleep(1000); // จำลองการทำงานโดยให้เวลา publisher ที่จะส่งข้อมูล
        }
    }
}

ใน Reactive Streams เราใช้หลักของการ Publisher และ Subscriber เพื่อดำเนินการแบบ non-blocking และ handling flow of data ซึ่งช่วยลด back pressure ได้เป็นอย่างดี

Usecase ในโลกจริง

การทำงานแบบ Async มีประโยชน์มหาศาลในแอปพลิเคชันต่างๆ เช่น:

การใช้งานวิธีการเหล่านี้ใน Java ไม่ได้เป็นเรื่องง่ายเสมอไป แต่ด้วยความเข้าใจที่ถูกต้องและการฝึกฝนปฏิบัติการอย่างสม่ำเสมอ นักพัฒนาสามารถเพิ่มประสิทธิภาพและสร้างแอปพลิเคชันที่รวดเร็วและมีประสบการณ์การใช้งานที่ดีได้

การเรียนรู้การเขียนโปรแกรมนั้นไม่เคยสายเกินไป อย่ารอช้าที่จะเริ่มต้นการเดินทางด้านการฝึกเขียนโค้ดของคุณที่ EPT ที่นี่ไม่เพียงแต่คุณจะได้พบกับหลักสูตรที่ครอบคลุมเรื่อง Asynchronous programming แต่ยังรวมถึงหลากหลายเทคโนโลยีใหม่ๆ ที่จะทำให้คุณก้าวหน้าไปในอาชีพการเป็นนักพัฒนาซอฟต์แวร์อีกด้วย!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง