การเขียนโปรแกรมแบบขนานโดยใช้ callable และอนาคต
วิธีที่พบบ่อยที่สุดในการเขียนโปรแกรมแบบขนานใน Java คือการสืบทอดคลาสเธรดหรือใช้อินเทอร์เฟซ Runnable ข้อเสียของวิธีการทั้งสองนี้คือผลการดำเนินการไม่สามารถรับได้โดยตรงหลังจากงานเสร็จสมบูรณ์และจะต้องมีการสื่อสารผ่านตัวแปรที่ใช้ร่วมกันหรือ inter-threads ซึ่งไม่สะดวกที่จะใช้
เริ่มต้นจาก Java 1.5 มีอินเทอร์เฟซ callable และในอนาคต โดยใช้พวกเขาคุณสามารถรับผลการดำเนินการหลังจากดำเนินการงาน
มาเรียนรู้วิธีใช้ callable, future และ futureTask
อินเทอร์เฟซที่เรียกได้
อินเทอร์เฟซ callable อยู่ในแพ็คเกจ java.util.concurrent นี่คืออินเทอร์เฟซทั่วไปที่ประกาศเฉพาะวิธีการโทร ():
อินเทอร์เฟซสาธารณะ callable <t> {t call () โยนข้อยกเว้น;}โดยทั่วไปจะใช้ร่วมกับอินเทอร์เฟซ ExecutorService มีการประกาศวิธีการส่งมากเกินไปหลายวิธีในส่วนต่อประสาน ExecutorService:
<t> อนาคต <t> ส่ง (งานเรียกได้ <t>); <t> อนาคต <t> ส่ง (งานที่รันได้, ผลลัพธ์ t); อนาคต <?> ส่ง (งาน runnable);
ประเภทพารามิเตอร์ในวิธีการส่งครั้งแรกนั้นสามารถเรียกได้และอีกสองข้อไม่ครอบคลุมโดยบทความนี้ในขณะนี้
อนาคตและ FutureTask
คลาสการใช้งานของอินเทอร์เฟซในอนาคตสามารถดำเนินการเช่นการยกเลิกการสืบค้นและการได้รับผลลัพธ์ในงานที่เรียกใช้หรือเรียกได้
อินเทอร์เฟซในอนาคตยังอยู่ภายใต้แพ็คเกจ java.util.concurrent:
อินเทอร์เฟซสาธารณะในอนาคต <t> { /***ยกเลิกงาน*@param mayinterruptifrunning*มันอนุญาตให้ยกเลิกงานที่ถูกดำเนินการ แต่ยังไม่เสร็จหรือไม่? หากตั้งค่าจริงหมายความว่างานในกระบวนการสามารถยกเลิกได้ *หากงานถูกดำเนินการจะส่งคืนจริง *หากงานยังไม่ถูกดำเนินการมันจะส่งคืนจริงไม่ว่าจะเป็น MayInterruptifrunning เป็นจริงหรือเท็จ */ บูลีนยกเลิก /***งานถูกยกเลิกสำเร็จหรือไม่? หากมีการยกเลิกสำเร็จก่อนที่งานจะเสร็จสมบูรณ์ตามปกติจะส่งคืน true */ boolean iscancelled (); / ***งานจะเสร็จสิ้น*/ บูลีน iSdone (); / ***รับผลการดำเนินการผ่านการปิดกั้น*/ t get () พ่น InterruptedException, ExecutionException; /***รับผลการดำเนินการผ่านการบล็อก หากไม่มีการส่งคืนส่งคืนภายในเวลาที่กำหนดให้ส่งคืน null */ t รับ (การหมดเวลายาว, timeUnit unit) พ่น InterruptedException, ExecutionException, TimeOutException;}เพื่อสรุปอนาคตมีสามฟังก์ชั่น:
ตรวจสอบว่างานเสร็จสมบูรณ์หรือไม่และสามารถขัดจังหวะงานและได้รับผลลัพธ์ของการดำเนินการงาน
JDK ให้เรามี FutureTask ระดับอินเทอร์เฟซในอนาคตซึ่งมีตัวสร้างสองตัวต่อไปนี้
Public FutureTask (callable <t> callable) {} FutureTask สาธารณะ (runnable runnable, ผลลัพธ์ t) {} รหัสตัวอย่าง
การใช้ Callable, Future
นำเข้า java.util.concurrent.*; การทดสอบคลาสสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {ExecutorService ExecutorService = Executors.newCachedThreadPool (); งานงาน = งานใหม่ (); อนาคต <integer> future = executorService.submit (งาน); ExecutorService.Shutdown (); System.out.println ("เธรดหลักกำลังดำเนินการงาน ... "); ลอง {thread.sleep (2000); } catch (interruptedException ex) {ex.printStackTrace (); } ลอง {system.out.println ("ผลการทำงานของงาน:"+future.get ()); } catch (interruptedException ex) {ex.printStackTrace (); } catch (executionException ex) {ex.printStackTrace (); } system.out.println ("งานทั้งหมดถูกดำเนินการแล้ว"); }} งานคลาสใช้ callable <teger> {@Override การเรียกใช้จำนวนเต็มสาธารณะ () โยนข้อยกเว้น {system.out.println ("เธรดลูกกำลังดำเนินการงาน ... "); // งานจำลองต้องใช้เวลาเธรด Time.sleep (5,000); กลับ 1,000; -ผลการดำเนินการ:
เธรดเด็กกำลังดำเนินงาน ... เธรดหลักกำลังดำเนินการงาน ... ผลการดำเนินงาน: 1,000 งานทั้งหมดได้ถูกดำเนินการ
ใช้ callable, futureTask
นำเข้า java.util.concurrent.*; การทดสอบคลาสสาธารณะ {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {ExecutorService ExecutorService = Executors.newCachedThreadPool (); งานงาน = งานใหม่ (); FutureTask <Integer> FutureTask = New FutureTask <Integer> (งาน); ExecutorService.submit (FutureTask); ExecutorService.Shutdown (); System.out.println ("เธรดหลักกำลังดำเนินการงาน ... "); ลอง {thread.sleep (2000); } catch (interruptedException ex) {ex.printStackTrace (); } ลอง {system.out.println ("ผลการทำงานของงาน:"+futureTask.get ()); } catch (interruptedException ex) {ex.printStackTrace (); } catch (executionException ex) {ex.printStackTrace (); } system.out.println ("งานทั้งหมดดำเนินการ"); }} งานคลาสใช้ callable <teger> {@Override การเรียกใช้จำนวนเต็มสาธารณะ () พ่นข้อยกเว้น {system.out.println ("เธรดลูกกำลังดำเนินการงาน ... "); // การจำลองงานใช้ thread.sleep (5000); กลับ 1,000; -ผลการดำเนินการ:
เธรดเด็กกำลังดำเนินงาน ... เธรดหลักกำลังดำเนินการงาน ... ผลการดำเนินงาน: 1,000 งานทั้งหมดได้ถูกดำเนินการ
สรุป
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้เกี่ยวกับการใช้ callable และอนาคตสำหรับการเขียนโปรแกรมแบบขนานใน Java ฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน เพื่อนที่สนใจสามารถอ้างถึงหัวข้ออื่น ๆ ที่เกี่ยวข้องในเว็บไซต์นี้ต่อไป หากมีข้อบกพร่องใด ๆ โปรดฝากข้อความไว้เพื่อชี้ให้เห็น ขอบคุณเพื่อนที่ให้การสนับสนุนเว็บไซต์นี้!