thread_8h-source.html

用来介绍ZIG Library游戏网络引擎的文档

00183 <span class="preprocessor">#endif</span>
00184 <span class="preprocessor"></span>                                <span class="keywordflow">if</span> (r != 0) {
00185                                         <a class="code" href="utils_8h.html#a1">FAILSTOP</a>();  <span class="comment">// trap "can't unlock" errors</span>
00186 <span class="comment">//                                      if (con) </span>
00187 <span class="comment">//                                              con-&gt;xprintf(5, "ERROR: MUTEX %i UNLOCK == %i\n", m, r);</span>
00188                                 }
00189                                 <span class="comment">//if (con) con-&gt;dprintf("MUTEX %i unlocked (%i)\n", m, r);</span>
00190                                 <span class="keywordflow">return</span> (r == 0);
00191                         }
00192                         <span class="keywordflow">else</span> {
00193                                 count_unlock(); <span class="comment">// do nothing, still more unlocks to go.</span>
00194                                 <span class="keywordflow">return</span> <span class="keyword">true</span>;
00195                         }
00196                 }
00197         }
00198 
00200         <span class="keyword">virtual</span> ~mutex_c() {
00201                 <span class="keywordtype">int</span> r;
00202 <span class="preprocessor">#ifdef USE_HAWKTHREADS</span>
00203 <span class="preprocessor"></span>                r = htMutexDestroy(&amp;m);
00204                 assert(r == 0);
00205                 r = htMutexDestroy(&amp;c);
00206                 assert(r == 0);
00207 <span class="preprocessor">#else</span>
00208 <span class="preprocessor"></span>                r = pthread_mutex_destroy(&amp;m);
00209                 assert(r == 0);
00210                 r = pthread_mutex_destroy(&amp;c);
00211                 assert(r == 0);
00212 <span class="preprocessor">#endif</span>
00213 <span class="preprocessor"></span>        }
00214 
00215 <span class="keyword">protected</span>:
00216 
00217 <span class="preprocessor">#ifdef USE_HAWKTHREADS</span>
00218 <span class="preprocessor"></span>        <span class="keywordtype">void</span> count_lock() { <span class="keywordtype">int</span> r = htMutexLock(&amp;c); <span class="keywordflow">if</span> (r != 0) <a class="code" href="utils_8h.html#a1">FAILSTOP</a>();    }
00219         <span class="keywordtype">void</span> count_unlock() { <span class="keywordtype">int</span> r = htMutexUnlock(&amp;c); <span class="keywordflow">if</span> (r != 0) <a class="code" href="utils_8h.html#a1">FAILSTOP</a>();        }
00220 <span class="preprocessor">#else</span>
00221 <span class="preprocessor"></span>        <span class="keywordtype">void</span> count_lock() { <span class="keywordtype">int</span> r = pthread_mutex_lock(&amp;c); <span class="keywordflow">if</span> (r != 0) <a class="code" href="utils_8h.html#a1">FAILSTOP</a>();     }
00222         <span class="keywordtype">void</span> count_unlock() { <span class="keywordtype">int</span> r = pthread_mutex_unlock(&amp;c); <span class="keywordflow">if</span> (r != 0) <a class="code" href="utils_8h.html#a1">FAILSTOP</a>(); }
00223 <span class="preprocessor">#endif</span>
00224 <span class="preprocessor"></span>        thread_id_t owner;      <span class="comment">// thread that owns the mutex and is inside the critical section</span>
00225         <span class="keywordtype">int</span> numlock; <span class="comment">// number of times the owner thread has locked</span>
00226         <a class="code" href="classconsole__c.html">console_c</a> *con; <span class="comment">//debugging...</span>
00227 
00228 <span class="keyword">private</span>:
00229 
00230 <span class="preprocessor">#ifdef USE_HAWKTHREADS</span>
00231 <span class="preprocessor"></span>        HTmutex m;
00232         HTmutex c;
00233 <span class="preprocessor">#else</span>
00234 <span class="preprocessor"></span>        pthread_mutex_t m; <span class="comment">//the mutex</span>
00235         pthread_mutex_t c; <span class="comment">//mutex for accessing the lock counter map</span>
00236 <span class="preprocessor">#endif</span>
00237 <span class="preprocessor"></span>
00238         <span class="comment">//non-copyable</span>
00239         mutex_c(<span class="keyword">const</span> mutex_c&amp;){}
00240         mutex_c &amp;operator=(<span class="keyword">const</span> mutex_c&amp;);
00241 };
00242 
00243 <span class="comment">//==================== MUTEX END =====================================================</span>
00244 
00247 <span class="keyword">template</span> &lt;<span class="keyword">class</span> T&gt; <span class="keyword">class </span>thread_c {
00248 <span class="keyword">public</span>:
00249 
00250         <span class="comment">// function pointer type</span>
00251   <span class="keyword">typedef</span> <span class="keywordtype">void</span>* (T::*FPTR_1)(<span class="keywordtype">void</span>*);
00252   <span class="keyword">typedef</span> <span class="keywordtype">void</span>* (T::*FPTR_2)(<span class="keywordtype">void</span>*,<span class="keywordtype">void</span>*);
00253   <span class="keyword">typedef</span> <span class="keywordtype">void</span>* (T::*FPTR_3)(<span class="keywordtype">void</span>*,<span class="keywordtype">void</span>*,<span class="keywordtype">void</span>*);
00254   <span class="keyword">typedef</span> <span class="keywordtype">void</span>* (T::*FPTR_4)(<span class="keywordtype">void</span>*,<span class="keywordtype">void</span>*,<span class="keywordtype">void</span>*,<span class="keywordtype">void</span>*);
00255 
00257         thread_c() { thread = THREAD_INVALID; 
00258         <span class="comment">//con = 0; </span>
00259         }
00260 
00262         <span class="comment">//thread_c(console_c *conio) { thread = THREAD_INVALID; con = conio; }</span>
00263 
00265         <span class="comment">//thread_c(pthread_t who /*, console_c *conio = 0*/) { thread = who; /*con = conio;*/ }</span>
00266 
00268         thread_c(<span class="keyword">const</span> thread_c &amp;t) { thread = t.thread; <span class="comment">/*con = t.con;*/</span> }
00269 
00271         thread_c &amp;operator=(<span class="keyword">const</span> thread_c &amp;t) { <span class="keywordflow">if</span> (*<span class="keyword">this</span> != t) { thread = t.thread; <span class="comment">/*con = t.con;*/</span> } <span class="keywordflow">return</span> (*this); }
00272 
00279         <span class="keywordtype">bool</span> create(T *cthis, FPTR_1 ptr2member, <span class="keywordtype">bool</span> joinable, <span class="keywordtype">void</span> *arg1) {
00280 
00281                 assert(thread == THREAD_INVALID);
00282                 zig_thread_runes_t *runes = <span class="keyword">new</span> zig_thread_runes_t; <span class="comment">// create thread args</span>
00283                 assert(runes);
00284                 runes-&gt;mythis = cthis; <span class="comment">// record the "this" for the call. will be used in pthread_run with a pointer to T::member_func</span>
00285                 runes-&gt;narg = 1;
00286                 runes-&gt;member_1 = ptr2member; <span class="comment">// record the pointer to member. will be used in pthread_run with the this for class T</span>
00287                 runes-&gt;arg1 = arg1;
00288                 runes-&gt;arg2 = (<span class="keywordtype">void</span>*)-666;
00289                 runes-&gt;arg3 = (<span class="keywordtype">void</span>*)-666;
00290                 runes-&gt;arg4 = (<span class="keywordtype">void</span>*)-666;
00291 <span class="preprocessor">#ifdef USE_HAWKTHREADS</span>
00292 <span class="preprocessor"></span>                NLboolean jo; <span class="keywordflow">if</span> (joinable) jo = NL_TRUE; <span class="keywordflow">else</span> jo = NL_FALSE;
00293                 thread = htThreadCreate(pthread_run, (<span class="keywordtype">void</span> *)runes, jo); <span class="comment">// create thread</span>
00294                 <span class="keywordflow">if</span> (thread == (HThreadID)HT_INVALID) { SAFEDELETE(runes); }
00295                 <span class="keywordflow">return</span> (thread != (HThreadID)HT_INVALID);
00296 <span class="preprocessor">#else</span>
00297 <span class="preprocessor"></span>                <span class="keywordtype">int</span> result = pthread_create(&amp;thread, 0, pthread_run, (<span class="keywordtype">void</span> *)runes); <span class="comment">// create thread</span>
00298                 <span class="keywordflow">if</span> (result != 0) { SAFEDELETE(runes); } <span class="keywordflow">else</span> { <span class="keywordflow">if</span> (joinable == <span class="keyword">false</span>) { <span class="keywordtype">int</span> r = pthread_detach( thread ); assert(r == 0); } }
00299                 <span class="keywordflow">return</span> (result == 0);
00300 <span class="preprocessor">#endif</span>
00301 <span class="preprocessor"></span>        }
00302 
00304         <span class="keywordtype">bool</span> create(T *cthis, FPTR_2 ptr2member, <span class="keywordtype">bool</span> joinable, <span class="keywordtype">void</span> *arg1, <span class="keywordtype">void</span> *arg2) {
00305                 assert(thread == THREAD_INVALID);
00306                 zig_thread_runes_t *runes = <span class="keyword">new</span> zig_thread_runes_t; <span class="comment">// create thread args</span>
00307                 assert(runes);
00308                 runes-&gt;mythis = cthis; <span class="comment">// record the "this" for the call. will be used in pthread_run with a pointer to T::member_func</span>
00309                 runes-&gt;narg = 2;
00310                 runes-&gt;member_2 = ptr2member; <span class="comment">// record the pointer to member. will be used in pthread_run with the this for class T</span>
00311                 runes-&gt;arg1 = arg1;
00312                 runes-&gt;arg2 = arg2;
00313                 runes-&gt;arg3 = (<span class="keywordtype">void</span>*)-666;
00314                 runes-&gt;arg4 = (<span class="keywordtype">void</span>*)-666;
00315 <span class="preprocessor">#ifdef USE_HAWKTHREADS</span>
00316 <span class="preprocessor"></span>                NLboolean jo; <span class="keywordflow">if</span> (joinable) jo = NL_TRUE; <span class="keywordflow">else</span> jo = NL_FALSE;
00317                 thread = htThreadCreate(pthread_run, (<span class="keywordtype">void</span> *)runes, jo); <span class="comment">// create thread</span>
00318                 <span class="keywordflow">if</span> (thread == (HThreadID)HT_INVALID) { SAFEDELETE(runes); }
00319                 <span class="keywordflow">return</span> (thread != (HThreadID)HT_INVALID);
00320 <span class="preprocessor">#else</span>
00321 <span class="preprocessor"></span>                <span class="keywordtype">int</span> result = pthread_create(&amp;thread, 0, pthread_run, (<span class="keywordtype">void</span> *)runes); <span class="comment">// create thread</span>
00322                 <span class="keywordflow">if</span> (result != 0) { SAFEDELETE(runes); } <span class="keywordflow">else</span> { <span class="keywordflow">if</span> (joinable == <span class="keyword">false</span>) { <span class="keywordtype">int</span> r = pthread_detach( thread ); assert(r == 0); } }
00323                 <span class="keywordflow">return</span> (result == 0);
00324 <span class="preprocessor">#endif</span>
00325 <span class="preprocessor"></span>        }
00326 
00328         <span class="keywordtype">bool</span> create(T *cthis, FPTR_3 ptr2member, <span class="keywordtype">bool</span> joinable, <span class="keywordtype">void</span> *arg1, <span class="keywordtype">void</span> *arg2, <span class="keywordtype">void</span> *arg3) {
00329                 assert(thread == THREAD_INVALID);
00330                 zig_thread_runes_t *runes = <span class="keyword">new</span> zig_thread_runes_t; <span class="comment">// create thread args</span>
00331                 assert(runes);
00332                 runes-&gt;mythis = cthis; <span class="comment">// record the "this" for the call. will be used in pthread_run with a pointer to T::member_func</span>
00333                 runes-&gt;narg = 3;
00334                 runes-&gt;member_3 = ptr2member; <span class="comment">// record the pointer to member. will be used in pthread_run with the this for class T</span>
00335                 runes-&gt;arg1 = arg1;
00336                 runes-&gt;arg2 = arg2;
00337                 runes-&gt;arg3 = arg3;
00338                 runes-&gt;arg4 = (<span class="keywordtype">void</span>*)-666;
00339 <span class="preprocessor">#ifdef USE_HAWKTHREADS</span>
00340 <span class="preprocessor"></span>                NLboolean jo; <span class="keywordflow">if</span> (joinable) jo = NL_TRUE; <span class="keywordflow">else</span> jo = NL_FALSE;
00341                 thread = htThreadCreate(pthread_run, (<span class="keywordtype">void</span> *)runes, jo); <span class="comment">// create thread</span>
00342                 <span class="keywordflow">if</span> (thread == (HThreadID)HT_INVALID) { SAFEDELETE(runes); }
00343                 <span class="keywordflow">return</span> (thread != (HThreadID)HT_INVALID);
00344 <span class="preprocessor">#else</span>
00345 <span class="preprocessor"></span>                <span class="keywordtype">int</span> result = pthread_create(&amp;thread, 0, pthread_run, (<span class="keywordtype">void</span> *)runes); <span class="comment">// create thread</span>
00346                 <span class="keywordflow">if</span> (result != 0) { SAFEDELETE(runes); } <span class="keywordflow">else</span> { <span class="keywordflow">if</span> (joinable == <span class="keyword">false</span>) { <span class="keywordtype">int</span> r = pthread_detach( thread ); assert(r == 0); } }
00347                 <span class="keywordflow">return</span> (result == 0);
00348 <span class="preprocessor">#endif</span>
00349 <span class="preprocessor"></span>        }
00350 
00352         <span class="keywordtype">bool</span> create(T *cthis, FPTR_4 ptr2member, <span class="keywordtype">bool</span> joinable, <span class="keywordtype">void</span> *arg1, <span class="keywordtype">void</span> *arg2, <span class="keywordtype">void</span> *arg3, <span class="keywordtype">void</span> *arg4) {
00353                 assert(thread == THREAD_INVALID);
00354                 zig_thread_runes_t *runes = <span class="keyword">new</span> zig_thread_runes_t; <span class="comment">// create thread args</span>
00355                 assert(runes);
00356                 runes-&gt;mythis = cthis; <span class="comment">// record the "this" for the call. will be used in pthread_run with a pointer to T::member_func</span>
00357                 runes-&gt;narg = 4;
00358                 runes-&gt;member_4 = ptr2member; <span class="comment">// record the pointer to member. will be used in pthread_run with the this for class T</span>
00359                 runes-&gt;arg1 = arg1;
00360                 runes-&gt;arg2 = arg2;
00361                 runes-&gt;arg3 = arg3;
00362                 runes-&gt;arg4 = arg4;
00363 <span class="preprocessor">#ifdef USE_HAWKTHREADS</span>
00364 <span class="preprocessor"></span>                NLboolean jo; <span class="keywordflow">if</span> (joinable) jo = NL_TRUE; <span class="keywordflow">else</span> jo = NL_FALSE;
00365                 thread = htThreadCreate(pthread_run, (<span class="keywordtype">void</span> *)runes, jo); <span class="comment">// create thread</span>
00366                 <span class="keywordflow">if</span> (thread == (HThreadID)HT_INVALID) { SAFEDELETE(runes); }
00367                 <span class="keywordflow">return</span> (thread != (HThreadID)HT_INVALID);
00368 <span class="preprocessor">#else</span>
00369 <span class="preprocessor"></span>                <span class="keywordtype">int</span> result = pthread_create(&amp;thread, 0, pthread_run, (<span class="keywordtype">void</span> *)runes); <span class="comment">// create thread</span>
00370                 <span class="keywordflow">if</span> (result != 0) { SAFEDELETE(runes); } <span class="keywordflow">else</span> { <span class="keywordflow">if</span> (joinable == <span class="keyword">false</span>) { <span class="keywordtype">int</span> r = pthread_detach( thread ); assert(r == 0); } }
00371                 <span class="keywordflow">return</span> (result == 0);
00372 <span class="preprocessor">#endif</span>
00373 <span class="preprocessor"></span>        }
00374 
00375         <span class="comment">// detach thread: it will be set to non-joinable</span>
00376         <span class="keywordtype">bool</span> detach() {
00377                 assert(thread != THREAD_INVALID);
00378                 <span class="keywordtype">int</span> r = pthread_detach( thread );
00379