نسخة الكود كما يلي:
حزمة com.yao ؛
استيراد 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 ، تم بدء مهمة عن طريق استدعاء طريقة Start () لفئة مؤشرات الترابط.
* يتم تقديم المهمة والتنفيذ في وقت واحد.
* أو التحكم في عدد المواضيع التي تم تنفيذها في وقت واحد يتطلب رمزًا إضافيًا لإكماله.
* 5.0 يوفر بنية جديدة لتنفيذ المهام تتيح لك جدولة المهام والتحكم فيها بسهولة.
* ويمكن إنشاء تجمع مؤشرات ترابط مشابه لمجموعة اتصال قاعدة البيانات لأداء المهام.
* تتكون هذه الهندسة المعمارية بشكل أساسي من ثلاث واجهات وفئاتها المحددة المقابلة.
*هذه الواجهات الثلاثة هي المنفذ ، executorservice و scrededexecutorservice.
* (1) واجهة المنفذ: يستخدم لتنفيذ المهام القابلة للتشغيل ، فهو يحدد طريقة واحدة فقط:
* تنفيذ (أمر Runnable): تنفيذ مهام نوع Ruannable
* (2) ExecutorService: يرث طريقة المنفذ ويوفر خدمات لتنفيذ مهام قابلة للاستدعاء وإحباط تنفيذ المهام.
* الطرق الرئيسية لتعريفها هي:
* إرسال (مهمة): يمكن استخدامه لتقديم مهام قابلة للاتصال أو قابلة للاتصال وإعادة الكائن المستقبلي الذي يمثل هذه المهمة
* Invokeall (مجموعة من المهام): مجموعة من المهام وإرجاع مجموعة من الكائنات المستقبلية التي تمثل هذه المهام.
* stutdown (): أغلق الخدمة بعد الانتهاء من المهمة المقدمة ولم تعد تقبل مهام جديدة.
* stakdownNow (): توقف جميع المهام التنفيذ وإغلاق الخدمة.
* iSterminated (): اختبار ما إذا كانت جميع المهام قد تم تنفيذها.
* isShutdown (): اختبار ما إذا كانت شركة ExecutorService قد تم إغلاقها
* (3) ScheduleDexecutorservice: وراثة ExecutorService ، وتوفير وظيفة مهام الجدولة وفقًا للوقت ،
* الجدول الزمني (المهمة ، initDelay): جدولة المهمة المقبولة أو القابلة للاتصال المقدمة ليتم تنفيذها بعد الوقت المحدد بواسطة initDelay.
* ScheduleAtfixedRate (): جدولة المهمة التي يتم تقديمها المقدمة ليتم تنفيذها بشكل متكرر في الفاصل الزمني المحدد.
* SchedulewithFixedDelay (): جدولة المهمة التي تم تقديمها المقدمة ليتم تنفيذها بشكل متكرر بعد كل تنفيذ ، انتظر الوقت المحدد عن طريق التأخير.
*
* الحصول على كائنات خدمة مختلفة من خلال فئة المنفذين.
* قابل للاتصال (المهمة القابلة للتشغيل): تحويل المهام القابلة للتشغيل إلى مهام قابلة للاستدعاء
* NewsingLethReadExecutor: يولد كائن SeviceSorsors ، الذي يحتوي على مؤشر ترابط واحد فقط يمكن استخدامه لتنفيذ المهام.
* NewCachedThreadPool (): سيتم ضبط كائن SeviceStorservice ، الذي يحتوي على مجموعة من تجمع الخيوط.
* NewfixedThreadPool (تجمع INT): يولد كائن من ExecutorSors ، والذي يحتوي على مجموعة من أحواض الحجم.
* NewsingleThreadScheduleDexecutor: يولد كائن ScripedExecutorService ، حجم تجمع مؤشر الترابط لهذا الكائن هو 1. إذا كان هناك أكثر من مهمة واحدة ، فسيتم تنفيذ المهام بالتسلسل.
* NewsCheduledThreadPool (INT Poolsize): يولد كائن ScripedExecutorservice ، فإن حجم تجمع مؤشر الترابط لهذا الكائن هو تجمع.
*/
الفئة العامة التنفيذية {
/**
* هذا الموضوع يخرج سلسلة
*/
الطبقة الثابتة العامة mythread تنفذ Runnable {
تشغيل الفراغ العام () {
System.out.println ("تكرار المهمة." + system.currentTimeMillis ()) ؛
يحاول {
thread.sleep (1000) ؛
} catch (InterruptedException e) {
System.out.println ("توقف المهمة."
+ system.currentTimeMillis ()) ؛
}
}
}
/**
* تنتهي المهمة الأخرى
*/
الفئة الثابتة العامة mycallable تنفس قابلة للاستدعاء {
المستقبل الخاص في المستقبل ؛
عام mycallable (المستقبل) {
this.future = المستقبل ؛
}
استدعاء السلسلة العامة () {
System.out.println ("لإلغاء المهمة ..."
+ + system.currentTimeMillis ()) ؛
this.future.cancel (true) ؛
إرجاع "المهمة ألغيت!" ؛
}
}
/**
* param args
* Throws ExecutionException
* throws interruptedException
*/
رميات الفراغ الثابتة العامة (سلسلة [] args)
ExecutionException {
// إنشاء كائن executorservice ، يحتوي على تجمع مؤشرات ترابط ، وسيتم ضبط حجم تجمع الخيوط حسب الحاجة.
// بعد تنفيذ مؤشر الترابط المهمة ، فإنه يعود إلى تجمع مؤشرات الترابط لاستخدام المهمة التالية.
ExecutorService CacheDservice = Executors.NewCacheDthReadPool () ؛
مستقبل mythreadfuture = cachedservice.submit (new mythread ()) ؛
مستقبل mycallableFuture = cachedservice.submit (جديد قابل للضرب (new mycallable (
mythreadfuture)) ؛
system.out.println (myCallableFuture.get ()) ؛
System.out.println ("-----------------") ؛
// تحويل المهام القابلة للتشغيل إلى مهام قابلة للاستدعاء
myThReadCallable القابل للاتصال = eveloperors.callable (new MyThread ()) ؛
مستقبل myThreadCallableFuture = cachedservice.submit (myThReadCallable) ؛
// للمهام القابلة للتشغيل ، لا يتم إرجاع أي قيمة بعد تحويلها إلى مهام قابلة للاستدعاء
system.out.println (myThReadCallableFuture.get ()) ؛
CacheDservice.shutdownNow () ؛
System.out.println ("-----------------") ؛
// إنشاء كائن executorservice ، يحتوي على مجموعة مؤشرات ترابط من حجم تجمعات الحجم.
// إذا كان عدد المهام أكبر من حجم التجمع ، فسيتم تنفيذ المهام في قائمة انتظار بالتسلسل
ExecutorService ثابتة = Executors.NewFixedThreadPool (2) ؛
ثابتة
ثابتة
// نظرًا لأن حجم تجمع الخيوط هو 2 ، يجب أن تنتظر المهام اللاحقة حتى يتم تنفيذ المهام السابقة قبل تنفيذها.
myThreadFuture = ثابتة
myCallableFuture = ثابتة.
system.out.println (myCallableFuture.get ()) ؛
ثابتة. shutdownnow () ؛
System.out.println ("-----------------") ؛
// إنشاء كائن SchedeDexecutorService ، حجم تجمع مؤشر الترابط لهذا الكائن هو تجمع.
// إذا كان عدد المهام أكبر من حجم التجمع ، فستنتظر المهمة التنفيذ في قائمة الانتظار
SchedeDexecutorService ثابتة
. newscheduledthreadpool (2) ؛
// إنشاء مهمة جديدة 1
MyThread Task1 = new MyThread () ؛
// استخدم خدمة تنفيذ المهمة لتنفيذ المهمة 1 على الفور ، ثم تنفيذ المهمة 1 كل ثانيتين بعد ذلك.
myThreadFuture = ثابتة
Timunit.Seconds) ؛
// إنشاء مهمة جديدة 2
myCallable Task2 = new mycallable (myThreadFuture) ؛
// استخدم خدمة تنفيذ المهام لانتظار 5 ثوان قبل تنفيذ المهمة 2. بعد تنفيذها ، سيتم إغلاق المهمة 1.
myCallableFuture = ثابتة
Timunit.Seconds) ؛
system.out.println (myCallableFuture.get ()) ؛
lextcheduledService.shutdownNow () ؛
}
}