1. المفاهيم الأساسية للموضوعات
فهم الموضوع: الموضوع هو مسار تنفيذ مختلف في البرنامج
يسمى كل فرع خيط ، ويسمى Main () الفرع الرئيسي ، ودعا أيضًا الخيط الرئيسي.
العملية هي مجرد مفهوم ثابت ، ملف .class على الجهاز ، ملف .exe على الجهاز ، وهذا ما يسمى العملية. تشبه عملية تنفيذ البرنامج: أولاً ، ضع رمز البرنامج في منطقة الكود للذاكرة. بعد وضع الرمز في منطقة الكود ، لا يبدأ التنفيذ على الفور. ومع ذلك ، هذا يعني أن العملية جاهزة للبدء. تم إنشاء العملية ، لكنها لم تبدأ في التنفيذ بعد. هذه هي العملية ، وبالتالي فإن العملية هي في الواقع مفهوم ثابت ولا يمكن نقله بنفسه. يشير تنفيذ العملية المعتادة إلى مؤشر الترابط الرئيسي في العملية التي تبدأ في التنفيذ ، أي أن الطريقة الرئيسية () تبدأ في التنفيذ. العمليات هي مفهوم ثابت ، وفي الواقع يتم تشغيل المواضيع في أجهزتنا.
يدعم نظام تشغيل Windows متعدد الخيوط. يمكنه تنفيذ العديد من المواضيع في نفس الوقت ويدعم أيضًا عمليات متعددة. لذلك ، فإن نظام تشغيل Windows هو نظام تشغيل يدعم المعالجة المتعددة والمعالجة المتعددة. Linux و Uinux هي أيضًا أنظمة تشغيل تدعم الخيوط المتعددة والمعالجة المتعددة. لا تدعم DOS متعددة الخيوط والمعالجة المتعددة. إنه يدعم العمليات الفردية فقط. يتم تنفيذ عملية واحدة فقط في نفس النقطة الزمنية ، والتي تسمى الخيوط الفردية.
هل وحدة المعالجة المركزية قوية حقًا وقادرة على تنفيذ الكثير من البرامج في نفس الوقت؟ لا ، إن تنفيذ وحدة المعالجة المركزية كما يلي: وحدة المعالجة المركزية سريعة للغاية ، ويمكن حسابها مئات الملايين من المرات في الثانية ، وبالتالي تقسم وحدة المعالجة المركزية وقته إلى شرائح زمنية صغيرة. أقوم بتنفيذ هذه المرة شريحة لفترة من الوقت ، في المرة القادمة سوف تنفذها لفترة من الوقت ، وسوف تنفذ الشريحة في المرة التالية للآخرين لفترة من الوقت. على الرغم من وجود العشرات من المواضيع ، يمكن تنفيذها جميعًا في وقت قصير جدًا. لكن بالنسبة لنا البشر ، فإن سرعة تنفيذ وحدة المعالجة المركزية سريعة للغاية ، لذلك يبدو أنها تنفذ في نفس الوقت ، ولكن في الواقع ، في وقت ما ، لا يوجد سوى سلسلة واحدة تعمل على وحدة المعالجة المركزية.
بادئ ذي بدء ، تحتاج إلى فهم ثلاثة مفاهيم عند تعلم المواضيع :
1. العملية: العملية مفهوم ثابت
2. موضوع: هناك مؤشر ترابط رئيسي في عملية تسمى Main () طريقة ، وهو برنامج ومسار تنفيذ مختلف في عملية.
3. في نفس الوقت ، يمكن لوحدة المعالجة المركزية دعم مؤشر ترابط واحد فقط للتنفيذ. نظرًا لأن وحدة المعالجة المركزية تعمل بسرعة كبيرة ، فإننا نبدو وكأننا متعددين.
ما هو التعدد الحقيقيات الحقيقية؟ إذا كان جهازك يحتوي على وحدة المعالجة المركزية المزدوجة أو النوى المزدوجة ، فهو بالفعل متعدد الخيوط.
2. خلق وبدء الخيوط
في Java ، يتم تنفيذ مؤشرات ترابط Java من خلال فئة Java.lang.Thread ، ويمثل كل كائن مؤشر ترابط مؤشر ترابط جديد. هناك طريقتان لإنشاء مؤشر ترابط جديد: الأول هو أن ترث من فئة مؤشرات الترابط ، والآخر هو تنفيذ الواجهة. عند بدء تشغيل VM ، سيكون هناك مؤشر ترابط محدد بواسطة الطريقة الرئيسية (الفراغ الثابت العام ()) ، ويسمى هذا الموضوع الخيط الرئيسي. يمكن إنشاء المواضيع الجديدة عن طريق إنشاء مثيلات من الخيط. تحتاج فقط إلى جدد كائن مؤشر ترابط ، وسيظهر مؤشر ترابط جديد. يكمل كل مؤشر ترابط تشغيله من خلال تشغيل الطريقة () المقابلة لكائن مؤشر ترابط معين. يسمى الطريقة Run () جسم الخيط.
مثال 1: إنشاء وبدء مؤشر ترابط جديد باستخدام تنفيذ الواجهة القابلة للتشغيل
قم بإنشاء موضوع جديد لاستدعاء طريقة التشغيل
Package Cn.Galc.test ؛ TestTrathread1 {public static void main (string args []) {runner1 r1 = new Runner1 () ؛ // هنا كائن جديد من فئة مؤشر الترابط يخرج // r1.run () ؛ // هذا يسمى استدعاء الطريقة. يتم تنفيذ استدعاء الطريقة هو الانتظار حتى يتم تنفيذ طريقة Run () قبل تنفيذ الطريقة الرئيسية (). موضوع T = مؤشر ترابط جديد (R1) ؛ // لبدء مؤشر ترابط جديد ، يجب أن يتم استخدام كائن مؤشر ترابط جديد // موضوع (هدف Runnable) هنا. يقوم المُنشئ T.Start () ؛ // بدء تشغيل مؤشر الترابط المفتوح حديثًا ، ويقوم مؤشر الترابط الجديد بتنفيذ طريقة Run () ، وسيتم تنفيذ مؤشر الترابط الجديد والموضوع الرئيسي بالتوازي لـ (int i = 0 ؛ i <10 ؛ i ++) {system.out.println ("meNtheod:"+i) ؛ }}}/*حدد فئة لتنفيذ واجهة Runnable. يعني تطبيق الواجهة القابلة للتشغيل أن هذه الفئة هي فئة مؤشرات ترابط*/class Runner1 تنفذ Runnable {public void run () {for (int i = 0 ؛ i <10 ؛ i ++) {system.out.println ("Runner1:"+i) ؛ }}}عملية تنفيذ البرامج متعددة الخيوط هي كما يلي:
استدعاء طريقة التشغيل مباشرة دون فتح موضوع جديد
نتائج التشغيل كما يلي:
مثال 2: ورث فئة مؤشرات الترابط وتجاوز طريقة Run () لإنشاء وبدء مؤشر ترابط جديد
Package Cn.Galc.test ؛/*الطريقة الثانية لإنشاء مؤشرات الترابط وبدء التشغيل: تحديد فئة فرعية من مؤشر الترابط وتنفيذ طريقة Run ()*/testthread2 {public static void main (String args []) {Runner2 r2 = new Runner2 () ؛ r2.Start () ؛ // استدعاء طريقة START () لبدء مؤشر الترابط المفتوح حديثًا لـ (int i = 0 ؛ i <= 10 ؛ i ++) {system.out.println ("mainMethod:"+i) ؛ }}}/*ترث فئة Runner2 من فئة مؤشر الترابط عن طريق إنشاء كائن من فئة Runner2 ، يمكنك فتح مؤشر ترابط جديد. استدعاء طريقة START () الموروثة من فئة الموضوع. يمكنك بدء تشغيل مؤشر الترابط الذي تم فتحه حديثًا*/Class Runner2 Thread {public void run () {// أعد كتابة طريقة التشغيل () لـ (int i = 0 ؛ i <= 10 ؛ i ++) {system.out.println ("runner2:"+i) ؛ }}}يجب إعطاء أولوية اختيار طريقتين لإنشاء مؤشرات ترابط جديدة ، وهي تنفيذ الواجهة القابلة للتشغيل وورث فئة الخيط ، الأولوية لفتح مؤشر ترابط جديد. نظرًا لأن تنفيذ الواجهة يمكن أن ينفذ متعددة ، فإن ميراث الفصل يمكن أن يكون مجرد ميراث واحد. لذلك ، عندما يمكنك استخدام واجهة Runnable عند فتح مؤشر ترابط جديد ، حاول ألا تستخدم الميراث من فئة مؤشرات الترابط لفتح مؤشرات ترابط جديدة.
3. انتقال حالة الموضوع
3.1. الطرق الأساسية للتحكم في الخيط
3.2. مقدمة لطريقة النوم/الانضمام/العائد
مثال على تطبيق طريقة النوم:
Package cn.galc.test ؛ import java.util.*؛ testthread3 {public static void main (String args []) {mythread thread = new MyThread () ؛ Thread.start () ؛ // استدعاء طريقة START () لبدء مؤشر الترابط المفتوح حديثًا ، حاول {/*thread.sleep(10000) ؛ Sleep () الطريقة هي طريقة ثابتة معلنة في فئة الخيط ، بحيث يمكنك استخدام تنسيق thread.sleep () للاتصال * / /*MyThread.sleep(10000) ؛ يرث فئة MyThread فئة مؤشرات الترابط ويرث أيضًا طريقة Sleep () بشكل طبيعي ، بحيث يمكنك أيضًا تسميتها باستخدام تنسيق mythread.sleep () *// *يمكن استدعاء نداء الأساليب الثابتة مباشرة في شكل "اسم الفئة. System.out.println ("ينام الخيط الرئيسي لمدة 10 ثوان ويبدأ مرة أخرى") ؛ // عند استدعاء الطريقة الثابتة لفئة أخرى في الطريقة الرئيسية () ، تحتاج إلى استخدام "Class.static Method Name حيث توجد الطريقة الثابتة" للاتصال /* لذلك هنا هو السماح للموضوع الرئيسي بالنوم لمدة 10 ثوانٍ. أي موضوع يدعو طريقة Sleep () ، لذلك ينام الخيط الرئيسي الآن. */} catch (interruptedException e) {E.PrintStackTrace () ؛ } //thread.interrupt() ؛//use interrupt () طريقة لإنهاء تنفيذ مؤشر ترابط. هذه طريقة أفضل لإنهاء خيط الطفل* / / *** استدعاء طريقة الاستدعاء () لكسر مؤشر الترابط الجري المكافئ لصب وعاء من الماء البارد على الخيط الرئيسي وكسر الخيوط الفرعية التنفيذ. بعد مقاطعة الخيوط الفرعية المنفذة ، سيتم إلقاء مقاطع مقاطع ، والتي ستنفذ عبارة الإرجاع وإنهاء تنفيذ الخيط. لذا فإن الخيط الفرعي هنا ينهي تنفيذ مؤشر الترابط بعد 10 ثوان من التنفيذ */}} الفئة myThread يمتد مؤشر الترابط {boolean flag = true ؛ استثناءات من طريقة إعادة الكتابة. * لذلك يمكنك فقط كتابة محاولة ... System.out.println ("======================================================================================================================================== ============================================================= ============================================================= ============================================================= ============================================================= ============================================================= =============================================================== بالطبع ، ليس من الخطأ تسميته باستخدام تنسيق "اسم الفصل. اسم الطريقة"*// mythread.sleep (1000) بدأت كل ثانية في حلقة ميتة ، ويتم طباعة وقت النظام الحالي كل ثانية} (interruptedException e) { /** عند النوم ، قد تقاطع لوحة من الماء البارد* لذلك ، قد يتم تقاطع الخيط الجاري عن طريق بعض الأسباب غير المتوقعة ، وهو ما يتم تقاطعه (تم تقاطعها). }}نتائج التشغيل:
مثال على طريقة الانضمام:
Package cn.galc.test ؛ testthread4 {public static void main (string args []) {mythread2 thread2 = new MyThread2 ("mythread") ؛ // أثناء إنشاء كائن مؤشر ترابط جديد ، قم بتسمية كائن مؤشر ترابط MyThread MyTherd2.Start () ؛ // بدء تشغيل مؤشر ترابط المحاولة {thread2.join () ؛ // استدعاء طريقة join () لدمج مؤشر الترابط ، ودمج MyThread لخيط الطفل في مؤشر الترابط الرئيسي // بعد دمج مؤشر الترابط ، وعملية التنفيذ للبرنامج معادٍ لعملية التنفيذ لاستدعاء الطريقة} } لـ (int i = 0 ؛ i <= 5 ؛ i ++) {system.out.println ("I are Main Thread") ؛ }}} class myThRead2 تمديد مؤشر الترابط {mythread2 (سلسلة s) {super (s) ؛ / * * استخدم الكلمة الرئيسية الفائقة لاستدعاء مُنشئ الفئة الأصل * أحد منشئي مؤشر ترابط الفئة الأصل: "موضوع السلاسل العامة (اسم السلسلة)" * من خلال مثل هذا المُنشئ ، يمكن تسمية الخيط المفتوح حديثًا ، والذي يسهل إدارة المواضيع */} باطلة باطلة عامة () {int i = 1 ؛ i <= 5 ؛ i ++) { getName ()) ؛ // استخدم // السلسلة النهائية العامة getName () المحددة في مؤشر ترابط الفئة الأصل ، إرجاع اسم هذا الموضوع. جرب {Sleep (1000) ؛ // اجعل خيط الطفل ينام لمدة ثانية واحدة في كل مرة يتم تنفيذه} catch (InterruptedException e) {return ؛ }}}}نتائج التشغيل:
مثال على استخدام طريقة العائد:
حزمة cn.galc.test ؛ فئة عامة testThread5 {public static void main (string args []) {mythread3 t1 = new MyThread3 ("T1") ؛ /* تم فتح خيوط طفل T1 و T2 في نفس الوقت. يقوم كل من T1 و T2 بتنفيذ طريقة Run ()*//*هناك ما مجموعه 3 مؤشرات ترابط بالتوازي أثناء تنفيذ هذا البرنامج ، أي الخيوط الفرعية T1 و T2 والخيط الرئيسي*/ MyThread3 T2 = جديد MyThread3 ("T2") ؛ T1.Start () ؛ // Starter Child Thread T1 T2.Start () ؛ // Starter Child Thread T2 لـ (int i = 0 ؛ i <= 5 ؛ i ++) {system.out.println ("i am thread") ؛ }}} class myThread3 يمتد thread {mythread3 (سلسلة s) {super (s) ؛ } public void run () {for (int i = 1 ؛ i <= 5 ؛ i ++) {system.out.println (getName () + ":" + i) ؛ إذا كان (i ٪ 2 == 0) {grield () ؛ // عندما يصل التنفيذ ، يمكن تقسيمه على 2 ، فسيتم إعطاء مؤشر الترابط الحالي وترك مؤشر ترابط آخر ينفذ طريقة التشغيل () يتم تنفيذها أولاً/ * * * يمكنك رؤيتها أثناء تشغيل البرنامج الأول ، * عند تنفيذ مؤشر الترابط (i ٪ 2 == 0). مرات ، سوف يعطي مؤشر ترابط إلى مؤشر ترابط T1 لتنفيذ الأولوية */}}}نتائج التشغيل كما يلي:
ما سبق هو كل محتوى هذه المقالة. نأمل أن تساعدك.