การคัดลอกรหัสมีดังนี้:
แพ็คเกจ com.yo;
นำเข้า java.util.concurrent.callable;
นำเข้า java.util.concurrent.executionException;
นำเข้า java.util.concurrent.executorservice;
นำเข้า java.util.concurrent.executors;
นำเข้า java.util.concurrent.future;
นำเข้า java.util.concurrent.scheduledexecutorservice;
นำเข้า java.util.concurrent.timeUnit;
-
* สถาปัตยกรรมการดำเนินการงานใหม่
* ก่อน Java 5.0 งานเริ่มต้นโดยการเรียกวิธีการเริ่มต้น () ของคลาสเธรด
* การส่งงานและการดำเนินการจะดำเนินการพร้อมกัน
* หรือการควบคุมจำนวนเธรดที่ดำเนินการพร้อมกันต้องใช้รหัสเพิ่มเติมเพื่อให้เสร็จสมบูรณ์
* 5.0 จัดเตรียมสถาปัตยกรรมการดำเนินการงานใหม่ที่ช่วยให้คุณกำหนดเวลาและควบคุมการดำเนินงานได้อย่างง่ายดาย
* และพูลเธรดที่คล้ายกับพูลการเชื่อมต่อฐานข้อมูลสามารถสร้างขึ้นเพื่อทำงาน
* สถาปัตยกรรมนี้ส่วนใหญ่ประกอบด้วยสามอินเทอร์เฟซและคลาสเฉพาะที่สอดคล้องกัน
*อินเทอร์เฟซทั้งสามนี้คือ Executor, ExecutorService และ ScheduleDexecutorService
* (1) อินเทอร์เฟซ Executor: ใช้ในการรันงาน Runnable เท่านั้นมันจะกำหนดวิธีเดียวเท่านั้น:
* ดำเนินการ (คำสั่ง runnable): ดำเนินงานประเภท ruannable
* (2) ExecutorService: สืบทอดเมธอดผู้ดำเนินการและให้บริการเพื่อเรียกใช้งานที่เรียกได้และการปฏิบัติงานยกเลิก
* วิธีการหลักของคำจำกัดความคือ:
* ส่ง (งาน): สามารถใช้เพื่อส่งงานที่เรียกได้หรือเรียกใช้งานได้และส่งคืนวัตถุในอนาคตที่เป็นตัวแทนของงานนี้
* Invokeall (คอลเลกชันของงาน): ชุดสะสมของงานและส่งคืนคอลเลกชันของวัตถุในอนาคตที่เป็นตัวแทนของงานเหล่านี้
* shutdown (): ปิดบริการหลังจากเสร็จสิ้นงานที่ส่งและไม่รับงานใหม่อีกต่อไป
* shutdownnow (): หยุดงานทั้งหมดที่ดำเนินการและปิดบริการ
* isterminated (): ทดสอบว่างานทั้งหมดถูกดำเนินการหรือไม่
* iSshutdown (): ทดสอบว่า ExecutorService ถูกปิดหรือไม่
* (3) ScheduleDexecutorService: สืบทอด ExecutorService ให้ฟังก์ชั่นของงานกำหนดเวลาตามเวลา
* กำหนดเวลา (งาน, initDelay): กำหนดเวลางานเรียกที่เรียกได้หรือ runnable ที่จะดำเนินการหลังจากเวลาที่ระบุโดย InitDelay
* ScheduleAtFixEdrate (): กำหนดเวลางานที่ส่งมาได้ที่ส่งมาเพื่อดำเนินการซ้ำ ๆ ตามช่วงเวลาที่กำหนด
* ScheduleWithFixedDelay (): กำหนดเวลางานที่ส่งมาได้ที่ส่งมาเพื่อดำเนินการซ้ำ ๆ หลังจากการดำเนินการแต่ละครั้งรอเวลาที่ระบุโดยความล่าช้า
-
* รับวัตถุบริการต่างๆผ่านคลาส Executors
* callable (งาน runnable): แปลงงาน Runnable เป็นงานเรียกได้
* NewsingLetHreadExecutor: สร้างวัตถุ ExecutorService ซึ่งมีเธรดเดียวที่สามารถใช้ในการดำเนินการงานได้
* Newcachedthreadpool (): สร้างวัตถุ Executorservice ซึ่งมีพูลเธรด
* NewFixedThreadPool (int poolsize): สร้างวัตถุ ExecutorService ซึ่งมีพูลพูลขนาดพูลขนาด
* NewsingLetHreadsCheduledExecutor: สร้างวัตถุ ScheduleDExecutorService ขนาดพูลของวัตถุนี้คือ 1 หากมีงานมากกว่าหนึ่งงานงานจะถูกดำเนินการตามลำดับ
* NewscheduledThreadPool (int poolsize): สร้างวัตถุ SchedExecutorservice ขนาดพูลของวัตถุนี้เป็นกลุ่มพูล
-
Executearch คลาสสาธารณะ {
-
* เธรดนี้ส่งออกสตริง
-
คลาสสแตติกระดับสาธารณะ MyThread ใช้งาน Runnable {
โมฆะสาธารณะเรียกใช้ () {
System.out.println ("งานซ้ำ" + System.currentTimeMillis ());
พยายาม {
Thread.sleep (1,000);
} catch (interruptedException e) {
System.out.println ("งานขัดจังหวะ"
+ System.currentTimeMillis ());
-
-
-
-
* callable สิ้นสุดงานอื่น
-
คลาสคงที่ระดับสาธารณะ mycallable ใช้ callable {
อนาคตส่วนตัวในอนาคต
สาธารณะ mycallable (อนาคตในอนาคต) {
this.future = อนาคต;
-
การเรียกสตริงสาธารณะ () {
System.out.println ("เพื่อยกเลิกงาน ... "
+ + System.currentTimeMillis ());
this.future.cancel (จริง);
กลับ "งานยกเลิก!";
-
-
-
* @param args
* @throws ExecutionException
* @throws interruptedException
-
โมฆะคงที่สาธารณะหลัก (String [] args) พ่น InterruptedException
ExecutionException {
// สร้างวัตถุ ExecutorService ซึ่งมีพูลเธรดและขนาดของพูลเธรดจะถูกปรับตามต้องการ
// หลังจากเธรดดำเนินการงานมันจะกลับไปที่พูลเธรดสำหรับงานถัดไปที่จะใช้
ExecutorService CachedService = Executors.newcachedThreadPool ();
Future MyThreadFuture = CachedService.submit (New Mythread ());
Future MyCallableFuture = CachedService.submit (MyCallable ใหม่ (ใหม่ (
MythreadFuture));
System.out.println (mycallablefuture.get ());
System.out.println ("-----------------");
// แปลงงาน Runnable เป็นงานที่เรียกได้
callable mythreadcallable = executors.callable (ใหม่ mythread ());
Future MyThreadCallableFuture = CachedService.submit (MyThreadCallable);
// สำหรับงานที่รันได้จะไม่มีการส่งคืนค่าหลังจากถูกแปลงเป็นงานที่เรียกได้
System.out.println (MyThreadCallableFuture.get ());
cachedservice.shutdownnow ();
System.out.println ("-----------------");
// สร้างวัตถุ ExecutorService ซึ่งมีเกลียวพูลขนาดพูลขนาด
// หากจำนวนงานมีค่ามากกว่าพูลขนาดงานจะถูกดำเนินการในคิวตามลำดับ
ExecutorService recidService = Executors.NewFixedThreadPool (2);
recideService.submit (New Mythread ());
recideService.submit (New Mythread ());
// เนื่องจากขนาดพูลเธรดคือ 2 งานที่ตามมาจะต้องรอให้งานก่อนหน้านี้ถูกดำเนินการก่อนที่จะสามารถดำเนินการได้
MyThreadFuture = RecideService.submit (New Mythread ());
MyCallableFuture = RecideService.submit (MyCallable ใหม่ (MyThreadFuture));
System.out.println (mycallablefuture.get ());
RecideService.ShutdownNow ();
System.out.println ("-----------------");
// สร้างวัตถุ ScheduleDexecutorService ขนาดพูลเธรดของวัตถุนี้คือ poolsize
// หากจำนวนงานมากกว่าพูลขนาดงานจะรอการดำเนินการในคิว
ScheduleDexecutorservice recidscheduledService = Executors
.newscheduledThreadpool (2);
// สร้างงานใหม่ 1
MyThread task1 = ใหม่ MyThread ();
// ใช้บริการการดำเนินการงานเพื่อดำเนินการงาน 1 ทันทีจากนั้นดำเนินการงาน 1 ทุก 2 วินาทีหลังจากนั้น
MyThreadFuture = RecideScheduledService.ScheduleatFixedrate (task1, 0, 2,
Timeunit.seconds);
// สร้างงานใหม่ 2
myCallable task2 = new myCallable (MyThreadFuture);
// ใช้บริการการดำเนินการงานเพื่อรอ 5 วินาทีก่อนที่จะดำเนินการงาน 2 หลังจากดำเนินการแล้วงาน 1 จะถูกปิด
MyCallableFuture = RecideScheduledService.Schedule (TASK2, 5, 5,
Timeunit.seconds);
System.out.println (mycallablefuture.get ());
recidescheduledservice.shutdownnow ();
-
-