Mereka yang telah membaca artikel saya sebelumnya mungkin tahu bahwa saya sedang melakukan pengembangan game. Banyak ide dan titik awal saya ditangani sesuai dengan ide -ide permainan, sehingga mungkin ada konflik dengan web dan tidak sejalan dengan itu.
Izinkan saya memberi tahu Anda mengapa saya ingin menyesuaikan model utas?
Menurut game MMORPG atau MMORPG yang saya buat, utas dibagi menjadi utas utama, utas sinkronisasi global, utas obrolan, utas tim, utas peta, dan distribusi pesan dan utas pengiriman, dll.
Beberapa kolom perlu dikontrol sesuai dengan divisi dan aliran data saya.
Hal utama yang harus dilakukan di server game adalah menerima permintaan perintah pemain -> Operasi yang sesuai -> Kembalikan hasilnya;
Semua pesan di sisi server akan terdaftar di Manajer Pesan, dan kemudian model utas akan ditentukan saat pesan terdaftar.
Jika pesan perlu dikirimkan ke utas peta pemain untuk diproses, saat mendaftarkan pesan, Anda harus menggunakan model utas (distribusi pesan peta dan utas pengiriman);
Mari kita analisis model utas terlebih dahulu;
Sebelum melihat kode model utas, pertama -tama saya melihat model tugas saya
Paket net.sz.engine.thread; import java.io.serializable; impor org.apache.log4j.logger; impor net.sz.engine.strukt.objectAttribute; impor net.sz.engine.structs.objectglobal;/** Model Tugas * * <br> <br> Author Program Fallingrammer <br> * moager; 13882122019 <br> */Public Abstract Class TaskEvent mengimplementasikan serializable, clonable {private static Final Logger Log = logger.getLogger (TaskEvent.class); SerialVersionUID Long Final Private Static = 4196020659994845804L; // data runtime private transient final objectAttribute runother = new ObjectAttribute; // Waktu Penciptaan Tugas Dilindungi CreateTime Long; // Tugas ID unik yang dilindungi tugas panjang; // BOOLEAN BOOLEAN BOOLEAN DISTROKTIF TUGAS = Salah; Tugas Publik {this.runother.put ("SubmitTime", System.CurrentTimeMillis); createTime = system.currentTimemillis; Batal = false; TaskId = ObjectGlobal.getuuid; } public long getCreateTime {return createTime; } public void setCreateTime (long createTime) {this.createTime = createTime; } public long getSubMittime {return this.runother.getLongValue ("SubmitTime"); } public ObjectAttribute getRunother {return runother; } public boolean iscancel {return cancel; } public void setCancel (boolean cancel) {this.cancel = batal; } public abstrak void run; Klon Objek Publik @Override melempar clonenotsupportedException {return super.clone; // Untuk mengubah tubuh metode yang dihasilkan, pilih Tools | Template. }}Paket net.sz.engine.thread;/** * pelaksana timer * * <br> * Penulis Gagal Programmer <br> * Mail [email protected] <br> * Telepon 13882122019 <br> */kelas abstrak public timertaskevent memperluas TaskEvent {private static static final long serialversionuid = -8662999999.8626 / *** Waktu untuk memulai Eksekusi*/ Dilindungi Long Starttime; / *** apakah akan mengeksekusi sekali di awal*/ startaction boolean yang dilindungi; / *** Waktu akhir*/ dilindungi waktu akhir panjang; / *** Jumlah Eksekusi*/ Int ActionCount yang Dilindungi; / *** Waktu eksekusi interval*/ interval interval waktu yang dilindungi; / **** @param Mulai Waktu Tentukan waktu mulai* @param isStartaction apakah akan dieksekusi sekali di awal* @param endtime menentukan waktu akhir* @param actionCount menentukan jumlah eksekusi* @param intervaltime menentukan waktu interval*/ public timertaskevent (start waktu long, boolean isstartaction, long end -end end -end*/ public timertaskevent (long starttime, boolean isstartaction, long end -end time; this.starttime = startTime; this.startaction = isStArtAction; this.endtime = endtime; this.actionCount = ActionCount; this.intervaltime = intervaltime; } /** * Specify the start execution time of the task* * @param startTime Specify the start time* @param isStartAction Whether it is executed once at the beginning* @param actionCount Specify the number of executions* @param intervalTime Specify the interval time*/ public TimerTaskEvent(long startTime, boolean isStartAction, int actionCount, int intervalTime) { this(startTime, isStartAction, 0, ActionCount, IntervalTime); } / *** Waktu akhir yang ditentukan adalah akhir zaman, dan jumlah eksekusi belum tentu cukup** @param isStartaction apakah akan mengeksekusi sekali pada awal* @param endtime menentukan waktu akhir* @param actionCount (boolean intervalTion, tentukan waktu interval* / public timertaskeVent (boolean iStactime, tentukan waktu interval* / public timertaskeVent (boolean iStactime waktu, interval waktu interval* / public timertaskeVent (boolean iStactime waktu, waktu interval* / public TimertaskeVent (boolean iStArtAme, Ini (0, ISstArtAction, Endtime, ActionCount, IntervalTime); } / *** Tentukan waktu mulai dan waktu akhir** @param starttime Tentukan waktu mulai* @param endtime Tentukan waktu akhir* @param intervaltime Tentukan waktu interval* / timertaskevent publik (waktu mulai lama, waktu akhir, interval interval) {this (starttime, false, endtime, -1, intervaltime); } / *** Waktu eksekusi yang ditentukan dan waktu interval** @param actionCount Tentukan jumlah eksekusi* @param intervaltime Tentukan waktu interval* / timertaskevent publik (int actionCount, int intervaltime) {this (0, false, 0, actionCount, intervaltime); } / *** Eksekusi tanpa batas setelah pengiriman* @param intervaltime waktu interval yang ditentukan* / timertaskevent publik (intervaltime int) {this (0, false, 0, -1, intervaltime); } public long getSartTime {return startTime; } public void setStarttime (Long StartTime) {this.starttime = startTime; } public boolean isstArtAction {return startaction; } public void setStartaction (boolean startaction) {this.startaction = startaction; } public long getEndtime {return endtime; } public void setendtime (panjang akhir) {this.endtime = endtime; } public int getActionCount {return actionCount; } public void setActionCount (int actionCount) {this.actionCount = actionCount; } public int getIntertime {return intervaltime; } public void setInterStime (int intervaltime) {this.intervaltime = intervaltime; }}
Berikut adalah model tugas dan model tugas timer;
Paket net.sz.engine.thread; impor java.util.arraylist; impor java.util.list; impor java.util.concurrent.concurrentlinkedqueue; impor net.sz.engine.structs.objectglobal; impor net.sz.engine.utils.mailutil; org.apache.log4j.logger; impor org.jboss.jandex.main;/** * Model utas * <br> * Penulis Gagal Programmer <br> * Mail [email protected] <br> Runnable 13882122019 <br> */Public Class ThreadModel Implement runnable {stasiat = PRIVED = PUBLIK PUBLIK PUBLIK PUBLIK PRIGLEPLEBLE {RUNNABLE {stor = PRIVED PRIMER = PUBLIK PUBLIC PRIMER = Logger.getLogger (threadmodel.class); threadid panjang statis pribadi = 0; Objek akhir statis yang dilindungi syn_object = objek baru; tid panjang yang dilindungi; nama string yang dilindungi; Dilindungi Long LastSendMail = 0; Daftar ArrayList akhir yang dilindungi <mythread> utas = Daftar Array baru <>; /*** Daftar Tugas Daftar Tugas Safe Thread*/// Daftar Akhir yang Dilindungi <KaskModel> TaskQueue = Daftar Array baru <>; final concurrentlinkedqueue final <askevent> Taskqueue = concurrentlinkedqueue baru <>; / ***/ Daftar Akhir Dilindungi <T TimertaskEvent> Timerqueue = ArrayList baru <>; // False Identity Delete Thread Protected Volatile Boolean Running = True; Public ThreadModel (ThreadGroup Group) {this (grup, "no name", 1); } public ThreadModel (nama string) {this (thishadpool.unknownthreadGroup, name, 1); } public threadModel (grup threadGroup, nama string, int threadCount) {this (grup, name, threadCount, null); } public ThreadModel (grup threadGroup, nama string, int threadCount, runnable runnable) {disinkronkan (syn_object) {threadId ++; tid = threadId; } untuk (int i = 1; i <= threadCount; i ++) {mythread thread; if (runnable == null) {thread = new mythread (tid, grup, this, name + "-" + tid + "-" + i);} else {thread = new mythread (tid, grup, runnable, name + "-} else {thread = new mythread (tid, group, runnable, name +"-} else {thread = new mythread (tid, group, runnable, name + "- } thread.start; threads.add (thread); } this.name = name; } / ** * Nama utas * * @return * / string publik getName {return name; } / ** * Dapatkan ID kustom utas * * @return * / public long getId {return this.tid; } / ** * Tambahkan tugas baru untuk setiap tugas baru, antrian tugas harus dibangunkan * * @param runnable * / public void addTask (TaskEvent runnable) {taskqueue.add (runnable); Sinkronisasi (TaskQueue) {/ * Bangun antrian dan mulailah mengeksekusi */ taskqueue.notifyall; }}/** * Tambahkan tugas timer ke utas * * @param runnable */public void addTimer (TimerTaskEvent runnable) {disinkronkan (timerqueue) {if (runing) {// jalan sekali di awal jika (runnable.startaction) {addtask) (runnable); } timerqueue.add (runnable);} else {log.error ("Thread telah berhenti"); }}}} // <editor-fold defaultState = "collapsed" desc = "Timer Thread Executor public void TimerRun"> / *** Timer Thread Executor* / public void timerrun {arrayList <T TimertaskEvent> TaskModels; disinkronkan (timerqueue) {// Jika antrian tidak kosong, keluarkan timer antrian TaskModels = new ArrayList <> (TimerQueue); } if (! TaskModels.isempty) {for (TimertaskEvent TimerEvent: TaskModels) {int execCount = timerevent.getRunother.gettinValue ("execcount"); Long Lasttime = timerevent.getRunother.getLongValue ("LastExecTime"); long nowTime = System.currentTimeMillis;if (lastTime == 0) {timerEvent.getRunOther.put("LastExecTime", nowTime);} else if (timerEvent.isCancel) {//If the task has been canceled synchronized (timerQueue) { timerQueue.remove(timerEvent); } log.debug ("Bersihkan Tugas Pengatur Waktu:" + TimerEvent.getClass.getName);} lain jika (sekarang waktu> timerevent.getStarttime // apakah waktu mulai dipenuhi && (sekarang - waktu ke -waktu. <timerevent.getEndtime) // Tentukan akhir waktu && (sekarang waktu - terakhir> = timerevent.getInterValtime)) // Tentukan apakah waktu interval telah dipenuhi sejak eksekusi terakhir {// pengirim eksekusi timer adalah yang pertama untuk mengeksekusi this.addtask (timerevent); // recordcount, "taperevent." execCount);timerEvent.getRunOther.put("LastExecTime", nowTime);nowTime = System.currentTimeMillis;// Determine the deletion condition if ((timerEvent.getEndTime > 0 && nowTime < timerEvent.getEndTime)|| (timerEvent.getActionCount > 0 && timerEvent.getActionCount <= execCount)) {synchronized (timerqueue) {timerqueue.remove (timerevent); } log.debug ("Tugas Timer Pembersih:" + Timerevent.getClass.getName); }}}}}}} // </editor-fold> // <editor-fold defaultState = "collapsed" desc = "Lihat stack utas public void showStackTrace">/**** Lihat stack utas*/public void showStackTrace {stringbuilder buf = new stringBuilder; untuk (MyThread CurrentThread: Threads) {long procc = system.currentTimeMillis - currentThread.getLastExecutetime; if (procc> 5 * 1000 && procc <86400000l) {// kurang dari 10 hari // karena waktu yang multithreading. Stuck-> ") .Append (procc/1000f) .Append (" S/N ") .Append (" Execute Task: ") .Append (currentThread.getLastCommand.getSclass.getName); coba {stacktraceElement elements = currentThread.getstackRace; for (int i = 0; i <lementraceElements = iLements; .penpend (elemen [i] .getClassName). lampai ("."). lampai (elemen [i] .getMethodName). lappend ("("). append (elemen [i] .getFileName). lappend (";"). append (elemen [i] .getlinNeNeNm) .pend (")"). " }} catch (Exception e) {buf.append (e); } buf.append ("/n +++++++++++++++++++++++++++++++++"); }} String toString = buf.toString; if (! Stringutil.isnullorempty (toString)) {log.error (toString); if (System.currentTimeMillis-lastsendmail> 5 * 60 * 1000) {lastsendmail = System.currentTimeMillis; mailutil.sendmail ("Thread Execution is Stuck--tuck- game" game- game- game- game- mailutil. Objectglobal.platform + "server id-" + objectglobal.serverid, tostring); }}} // </editor-fold> @Override public void run {mythread currentThread = (mythread) thread.currentThread; while (runing) {while (taskqueue.isempty && running) {coba {/* antrian tugas kosong, maka tugas baru menunggu tugas baru untuk bergabung dan dibangunkan*/disinkronkan (taskqueue) {taskqueue.wait (500); }} catch (InterruptedException IE) {LOG.Error (IE); }}/* Keluarkan tugas untuk mengeksekusi*/if (runing) {currentThread.LastCommand = null; currentThread.LastCommand = taskqueue.poll; } if (currentThread.LastCommand! = null) {if (currentThread.LastCommand.iscancel) {// Jika tugas telah dibatalkan, lanjutkan; }/* Jalankan tugas* /// r.setsubmittimel; currentThread.LastExecutetime = System.currentTimeMillis; coba {currentThread.LastCommand.run;} catch (excutation e) {log.error ("worker <" " + CurrentThread.getName.3"> EXECUCECEM ("Worker <" " + CurrentThread.getName.GetName.EKUCICEM.EKUP.REGLASS.RED.RED.RED.RED.RED.RED.GREAD.GEAD.GEAD. "> Kesalahan ditemui:", e); } long timel1 = system.currentTimemillis - currentThread.LastExecutetime; if (timel1 <= 20) {} lain jika (timel1 <= 100l) {log.info ("pekerja <" " + currentThread.getName +" "menyelesaikan tugas:" + currentThread.lastCommand.toString + "waktu eksekusi:" + timel1);} lain jika (timel1 <= 200 loucher) {" + timel1);} lain if (timel1 <= 200 getname) {" + timel1);} lain if (timel1 <= 200 getname) {" + timel1);} lain if (timel1 <= 200 {" + {" + timel1; + ""> Eksekusi Penyelesaian Tugas Jangka Panjang: " + CurrentThread.LastCommand.Tostring +" "Pertimbangkan" Tugas Logika Menyesuaikan waktu: " + Timel1);} else {log.info (" Pekerja <"" + saat ini. menghapus "skrip tugas yang memakan waktu:" + timel1); } currentThread.LastExecutetime = 0; }} log.Error ("Ujung utas, pekerja <" " + thread.currentThread.getName +" "> keluar"); } / *** Utas khusus* / kelas publik MyThread memperluas utas { / **** @param tid kustom thread id* @param grup grup* @param menjalankan metode eksekusi* @param nama utas* / public mythread (long tid, threadGroup grup, runnable run, string name) {super (grup, run, name); this. } // ID khusus dari utas publik long _id; // Tugas Eksekusi Publik Volatile TaskEvent LastCommand; // Waktunya mulai melaksanakan tugas publik yang mudah menguap langka lastExecutetime = 0; Tugas Publik GetLastCommand {Return LastCommand; } public long getLastExecutetime {return lastexecutetime; } / ** * Return Thread Custom ID * * @Return * / @Override Public long getId {return _id; }} / *** Hentikan utas, atur status berhenti utas, dan tidak akan segera mengakhiri utas* / public void stop {this.runing = false; } public boolean isruning {return running; } @Override public string toString {return "thread {" + "tid =" + tid + ", name =" + this.getName + '}'; }}
Saya dibangun dari threadmodel
Public ThreadModel (grup threadGroup, nama string, int threadcount, runnable runnable) {disinkronkan (syn_object) {threadId ++; tid = threadId; } untuk (int i = 1; i <= threadCount; i ++) {mythread thread; if (runnable == null) {thread = new mythread (tid, grup, this, name + "-" + tid + "-" + i);} else {thread = new mythread (tid, grup, runnable, name + "-} else {thread = new mythread (tid, group, runnable, name +"-} else {thread = new mythread (tid, group, runnable, name + "- } thread.start; threads.add (thread); } this.name = name; }Seperti yang bisa dilihat, di sini saya menjalankan kelas utas mythread dinyatakan
Mengapa saya memikirkan hal ini? Misalnya, jika saya memproses data penulisan log, seperti tidak ada data bersama, dan tidak ada aliran pemrosesan area kritis utas, saya dapat mempertimbangkan untuk menggunakan n utas untuk memproses pekerjaan tersebut; itu tidak akan menghasilkan data kotor;
Jika saya ingin bekerja sama dan meminta casting keterampilan, saya perlu memproses satu antrian, maka hanya ada satu mythread di threadmodel. Ini tidak dihitung sebagai eksekusi serial mode pemblokiran (atau eksekusi antrian) untuk menyelesaikan masalah berbagi data dan area kritis utas, yang tidak lagi tergantung pada kunci;
Saya sangat jelek, maafkan saya
Seperti yang ditunjukkan pada gambar di atas, akan ada dua antrian di setiap threadmodel, satu timeTaskEvent dan tugas lainnya, dan akan ada utas pengatur waktu global;
Fungsi utas timer global adalah untuk memproses dan menemukan bahwa TimeTaskEvent dalam threadModel perlu dieksekusi, sehingga ditambahkan ke tim Taskvent; Eksekusi akhir adalah antrian tugas
Mengapa TimeTaskEvent harus disimpan dalam threadmodel yang sesuai? Itu karena, misalnya, setelah utas saya A (instance ThreadModel) berjalan untuk jangka waktu tertentu, saya perlu menutup dan membebaskan sumber daya, jadi saya harus pergi ke tempat lain untuk menemukan jadwal yang sesuai dan menghapusnya;
package net.sz.engine.thread;import java.util.HashMap;import java.util.Map;/** * * <br> * author Falling programmer<br> * mail [email protected]<br> * phone 13882122019<br> */class TimerThread extends Thread { private static final Object SYN_OBJECT = new Object; TimerThread publik {super (threadpool.globlThreadGroup, "Global Timer Thread"); } @Override public void run { while (true) {synchronized (SYN_OBJECT) {try {SYN_OBJECT.wait(2);} catch (InterruptedException ex) { } }HashMap<Long, ThreadModel> hashMap = new HashMap<>(ThreadPool.getThreadMap);for (Map.Entry<Long, ThreadModel> entrySet : hashmap.entryset) {key panjang = entryset.getKey; threadModel value = entryset.getValue; value.timerrun; }}}}
Manajer Model Thread
Paket net.sz.engine.thread; impor java.util.hashmap; impor java.util.concurrent.concurrenthashmap; impor net.sz.engine.script.manager.scriptManager; impor net.sz.engine.globtimerevent; impor net.sz.engine.engine.timer.globtimerevent; impor net.szer.engine.engine.dimer.globtimerevent; impor net.sz.engine.engine org.apache.log4j.logger;/** * Thread Manager * * <br> * Penulis Gagal Programmer <br> * Mail [email protected] <br> * Telepon 13882122019 <br> */Kelas Publis Utas {static private Logger Log = Logger.getlogger (threadpool.tandpool.tandpool) {static private logger log = logger.getlogger.tandpool.tandpool.tandpool); Globlthread Panjang Publik Statis; TimerThreadGloadTimerThread final privat statis; Final Long CheckthreadTimerThreadModel statis; statis publik threadgroup globlThreadGroup = new threadGroup ("global threadgroup"); ThreadGroup akhir publik statis unknownthreadgroup = threadgroup baru (globlThreadGroup, "threadgroup tidak diketahui"); statis private concurrenthashMap <land threadModel> threadMap = concurrenthashmap baru <>; public static void main (string [] args) {threadpool.addtimertask (globlThread, timertaskevent baru (1000) {@Overridepublic void run {log.error ("sssss");}}); } static {// Buat thread global globlThread = addThreadModel (GloblThreadGroup, "GloblThread"); // Jalankan waktu tugas yang ditentukan untuk memicu langkah kaki addtimertask (GloblThread, GlobTimerEvent baru (ScriptManager.getInstance.getbasescripentry)); // query Model timing konsumsi server addtimertask (globlThread, printlnservermemoryTimerevent baru); // Buat utas timer globltimerThread = timerThread baru; Globltimerthread.start; // periksa utas stick checkthreadtimerThreadModel = addThreadModel (globlThreadGroup, "periksa acara threadtimer"); AddTimertask (chectreadtimerThreadModel, checkthreadtimerevent baru); } / ** * Saat menghapus model utas ID yang ditentukan, atur status ke status stop * * @param tid * @return * / statis threadmodel hapus (tid panjang) {threadModel lepas = threadmap.remove (tid); if (hapus! = null) {remove.stop; } return hapus; } / ** * Dapatkan semua utas di kumpulan utas * * @return * / statis public concurrenthashMap <long, threadModel> getThreadMap {return threadMap; } / ** * Dapatkan utas di kumpulan utas * * @param threadId * @return * / statis threadmodel getThreadModel (long threadId) {threadModel get = threadMap.get (threadId); if (get == null) {LOG.Error ("Model utas tidak dapat ditemukan:" + threadId, pengecualian baru ("Model Thread tidak dapat ditemukan:" + threadId)); } return get; } / ** * Daftarkan utas ke kumpulan utas * <br> * pengelompokan default unknownthreadgroup * * @param Nama utas nama * @return * / statis public long addThreadModel (nama string) {return addThreadModel (unknownthreadgroup, name); } / ** * Daftarkan utas ke kumpulan utas * <br> * pengelompokan default unknownthreadgroup * * @param nama threadname * @param threadcount threadcount * @return * / static public long addThreadModel (nama string, threadcount) {addThreadModel (unknownthreadGroup, name, threadcount); } / *** Daftarkan utas dengan kumpulan utas** @param grup informasi pengelompokan utas* @param Nama utas nama* @return* / static public long addThreadModel (grup threadgroup, nama string) {return addThreadModel (grup, name, 1); } / *** Daftarkan utas dengan kumpulan utas** @param grup informasi pengelompokan utas* @param nama threadname* @param threadcount threadcount* @return* / static public long addThreadModel (grup threadgroup, string name, int threadcount) {return addThreadModel (grup, name, null, threadcount); } /** * Register a thread with the thread pool* * @param group Threadgroup information* @param name Threadname* @param runnable * @param threadcount Threadcount* @return */ static public long addThreadModel(ThreadGroup group, String name, Runnable runnable, int threadcount) { ThreadModel threadModel = new ThreadModel(group, name, threadcount, runnable); Return AddThreadModel (ThreadModel); } / ** * Daftarkan utas dengan kumpulan utas * * @param threadModel * / statis public long addThreadModel (threadModel threadModel) {threadMap.put (threadModel.getId, threadModel); return threadModel.getId; } / ** * Tambahkan tugas * * @param threadId * @param Task * @return * / static public boolean addTask (long threadId, tugas TaskEvent) {threadModel threadModel = getThreadModel (threadId); if (threadModel! = null) {threadModel.addtask (tugas); return true; } return false; } / ** * Tambah tugas timer * * @param threadId * @param Task * @return * / static public boolean addtimertask (long threadId, timertaskevent tugas) {threadModel threadModel = getTreadModel (threadId); if (threadModel! = null) {threadModel.addtimer (tugas); return true; } return false; } / ** * Tambahkan tugas, tambahkan tugas ke utas saat ini * * @param Task * @return * / static public boolean addCurrentThreadTask (tugas TaskEvent) {thread currentThread = thread.currentThread; if (currentThread dari threadModel.mythread) {long threadId = currentThread.getId; threadModel threadModel = getThreadModel (threadId); if (threadModel! = null) {threadModel.addtask (tugas); return true; }} return false; } / ** * Tambahkan tugas timer dan tambahkan tugas ke utas saat ini * * @param Task * @return * / static public boolean addCurrentThreadTimertask (TimerSaskEvent Task) {thread currentThread = thread.currentThread; if (currentThread dari threadModel.mythread) {long threadId = currentThread.getId; threadModel threadModel = getThreadModel (threadId); if (threadModel! = null) {threadModel.addtimer (tugas); return true; }} return false; }}
Selanjutnya, mari kita lihat penggunaannya
Kode Pendahuluan Thread Dalam artikel sebelumnya
public static void main (String [] args) melempar InterruptedException {// Thread Parallelism, beberapa utas menjalankan beberapa tugas/fungsi utas baru (run1 baru) .start; utas baru (run2 baru) .start; } // Task1 Static Class Run1 mengimplementasikan runnable {@Override public void run {// Execute Task 1 run1; // Execute Task 3 run3; }} // Task2 Static Class Run2 mengimplementasikan runnable {@Override public void run {// Execute Task 3 run3; // Jalankan Tugas 1 run1; // Jalankan Tugas 2 Run2; }} // Tugas 1 public static void run1 {System.out.println ("run1->" + System.currentTimeMillis); } // Tugas 2 public static void run2 {System.out.println ("run2->" + system.currentTimeMillis); } // Tugas 3 public static void run3 {System.out.println ("run3->" + system.currentTimeMillis); }Saya mengubah kode ke mode
public static void main (string [] args) melempar InterruptedException {// Thread adalah paralel, beberapa utas menjalankan beberapa tugas/fungsi test long1 = threadpool.addthreadModel ("Test Thread-1"); Long test2 = threadpool.addthreadModel ("Test Thread-2"); // Tambahkan Tugas ThreadPool.AddTask (test1, new run1); Threadpool.addtask (test2, run2 baru); // Tambahkan Timer Task ThreadPool.AddTimertask (test1, new TimeRrun1); Threadpool.addtimertask (test2, new timeRrun2); } // Task1 Static Class Run1 memperluas TaskEvent {@Override public void run {// Execute Task 1 run1; // Jalankan tugas 3 run3; }} // Task1 Static Class TimErrun1 memperluas timertaskevent {public timeRrun1 {super (500); // 500ms Eksekusi tanpa batas} @Override public void run {// Jalankan Tugas 1 run1; // Jalankan Tugas 3 Run3; }} // Task2 Static Class Run2 Memperluas TaskEvent {@Override public void run {// Jalankan Tugas 3 Run3; // Jalankan Tugas 1 Run1; // Jalankan Tugas 2 Run2; }} // Task2 Static Class TimErrun2 memperluas timertaskevent {public timeRrun2 {super (500); // 500ms Eksekusi tanpa batas} @Override public void run {// Jalankan Tugas 3 run3; // Jalankan Tugas 1 run1; // Execute Task 2 run2; }} // task1 public static void run1 {System.out.println ("run1->" + System.currentTimeMillis); } // task2 public static void run2 {System.out.println ("run2->" + system.currentTimeMillis); } // Tugas 3 public static void run3 {System.out.println ("run3->" + system.currentTimeMillis); }Selanjutnya, mari kita lihat efek eksekusi
run1-> 1472120543013run3-> 1472120543013run3-> 1472120543017Run1-> 1472120543017Run2-> 14721205 43017Run1-> 1472120543517Run3-> 1472120543517Run2-> 1472120543517Run1-> 1472120544018Run3-> 147 2120544018Run2-> 1472120544018Run1-> 1472120544520Run3-> 1472120544520Run2-> 1472120544520Run1 -> 1472120545021Run3-> 1472120545021Run2-> 1472120545021Run1-> 1472120545521Run3-> 1472120545521
Semuanya normal;
Ini adalah model threading kustom saya;
Pada titik ini, model threading kustom saya telah selesai;
Jadi apa kelebihan dan kekurangannya?
Keuntungannya adalah bahwa kontrol aliran data sangat jelas, termasuk situasi eksekusi saat ini, serta pemantauan utas yang macet dan eksekusi timer tugas;
Kerugian, model utas kustom ini masih tidak dapat menyelesaikan masalah keamanan data utas dan area kritis, dan masih perlu diselesaikan dengan kunci atau formulir lain pada waktu yang tepat;
Saya berharap para dewa agung akan menunjukkan kekurangannya, jadi saya dapat segera memperbaikinya.