thread_8h-source.html

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

00380                 <span class="comment">// ****** REVIEW: ****** </span>
00381                 <span class="comment">// - we're detaching the thread; when it terminates, it will free itself. so we don't need</span>
00382                 <span class="comment">//   the handle anymore, do we?</span>
00383                 <span class="comment">// - setting the handle to "invalid" helps us catch a later attempt to join the thread. or not.</span>
00384 
00385                 assert(r == 0);
00386                 <span class="keywordflow">return</span> <span class="keyword">true</span>;
00387         }
00388 
00390         <span class="keywordtype">void</span> invalidate_handle() {
00391                 thread = THREAD_INVALID;
00392         }
00393 
00396         <span class="keywordtype">bool</span> join(<span class="keywordtype">void</span> **value_ptr, <span class="keywordtype">int</span> *res = 0) {
00397 
00398                 assert(thread != THREAD_INVALID);
00399 
00400                 <span class="comment">//check if joining with itself</span>
00401                 <span class="comment">// A NON ZERO VALUE IS RETURNED IF THEY REFER TO THE SAME THREAD</span>
00402 <span class="comment">//              if (pthread_equal( thread, pthread_self() ) != 0) {</span>
00403                 <span class="keywordflow">if</span> (thread_equal( thread, current_thread())) {
00404                         <span class="comment">//TRYING TO JOIN WITH ITSELF!! BAD!</span>
00405                         <span class="comment">//con-&gt;xprintf(5, "ERROR: JOIN ERROR self = %i, thread = %i\n", pthread_self(), thread );</span>
00406                         <a class="code" href="utils_8h.html#a1">FAILSTOP</a>();
00407                 }
00408 
00409 <span class="preprocessor">#ifdef USE_HAWKTHREADS</span>
00410 <span class="preprocessor"></span>                <span class="keywordtype">int</span> result = htThreadJoin(thread, value_ptr);
00411 <span class="preprocessor">#else</span>
00412 <span class="preprocessor"></span>                <span class="keywordtype">int</span> result = pthread_join(thread, value_ptr);
00413 <span class="preprocessor">#endif</span>
00414 <span class="preprocessor"></span>                thread = THREAD_INVALID;
00415                 <span class="keywordflow">if</span> (res) { (*res) = result; }
00416                 <span class="keywordflow">return</span> (result == 0);
00417         }
00418  
00419 
00421         <span class="keywordtype">bool</span> running() { <span class="keywordflow">return</span> (thread != THREAD_INVALID); }
00422 
00424         <span class="comment">//bool equals(thread_c *t) { return (pthread_equal(thread, t-&gt;thread) == 0); }</span>
00425 
00427         <span class="comment">//pthread_t get_handle() { return thread; }</span>
00428         <span class="comment">//thread_id_t get_handle() { return thread; }</span>
00429 
00431         <span class="keyword">virtual</span> ~thread_c() { }
00432 
00433 <span class="keyword">protected</span>:
00434 
00435         <span class="comment">//pthreads entry point - pass instance of thread_c!</span>
00436         <span class="keyword">static</span> <span class="keywordtype">void</span> *pthread_run(<span class="keywordtype">void</span> *arg) {
00437 
00438                 zig_thread_runes_t *runes = (zig_thread_runes_t *)arg;
00439                 <span class="keywordtype">void</span> *ret = (<span class="keywordtype">void</span>*)-666;
00440                 <span class="keywordflow">if</span> (runes-&gt;narg == 1)
00441                         ret = (runes-&gt;mythis-&gt;*runes-&gt;member_1)(runes-&gt;arg1); <span class="comment">// call C::f function ptr over cthis</span>
00442                 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (runes-&gt;narg == 2)
00443                         ret = (runes-&gt;mythis-&gt;*runes-&gt;member_2)(runes-&gt;arg1,runes-&gt;arg2); <span class="comment">// call C::f function ptr over cthis</span>
00444                 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (runes-&gt;narg == 3)
00445                         ret = (runes-&gt;mythis-&gt;*runes-&gt;member_3)(runes-&gt;arg1,runes-&gt;arg2,runes-&gt;arg3); <span class="comment">// call C::f function ptr over cthis</span>
00446                 <span class="keywordflow">else</span> <span class="keywordflow">if</span> (runes-&gt;narg == 4)
00447                         ret = (runes-&gt;mythis-&gt;*runes-&gt;member_4)(runes-&gt;arg1,runes-&gt;arg2,runes-&gt;arg3,runes-&gt;arg4); <span class="comment">// call C::f function ptr over cthis</span>
00448                 <span class="keywordflow">else</span> {
00449                         <a class="code" href="utils_8h.html#a1">FAILSTOP</a>();
00450                 }
00451 
00452                 SAFEDELETE(runes); <span class="comment">//delete runes</span>
00453                 <span class="keywordflow">return</span> ret; <span class="comment">// implicit call to pthread_exit().</span>
00454         }
00455 
00456         <span class="comment">// thread args</span>
00457         <span class="keyword">struct </span>zig_thread_runes_t {
00458                 T* mythis;
00459                 <span class="keywordtype">int</span> narg;
00460                 FPTR_1 member_1;
00461                 FPTR_2 member_2;
00462                 FPTR_3 member_3;
00463                 FPTR_4 member_4;
00464                 <span class="comment">//user's thread function arguments:</span>
00465                 <span class="keywordtype">void</span> *arg1;
00466                 <span class="keywordtype">void</span> *arg2;
00467                 <span class="keywordtype">void</span> *arg3;
00468                 <span class="keywordtype">void</span> *arg4;
00469         };
00470 
00471 <span class="keyword">private</span>: 
00472 
00473         <span class="comment">// the thread handle</span>
00474         <span class="comment">//pthread_t     thread;</span>
00475         thread_id_t thread;
00476 
00477         <span class="comment">//debugging...</span>
00478 <span class="comment">//      console_c *con;</span>
00479 };
00480 
00481 <span class="comment">// ZIG 1.4.0: take off thread priority stuff if no pthreads</span>
00482 <span class="preprocessor">#ifndef ZIG_NO_PTHREADS</span>
00483 <span class="preprocessor"></span>
00485 <span class="keywordtype">int</span> get_prio(pthread_t *who);
00486 
00488 <span class="keywordtype">int</span> get_min_prio();
00489 
00491 <span class="keywordtype">int</span> get_max_prio();
00492 
00494 <span class="keywordtype">int</span> get_prio_incval();
00495 
00497 <span class="keywordtype">void</span> set_prio(pthread_t *who, <span class="keywordtype">int</span> targ_prio);
00498 
00499 <span class="preprocessor">#endif</span>
00500 <span class="preprocessor"></span>
00501 <span class="comment">// ================================================</span>
00502 <span class="comment">// DEPRECATED THREADS STUFF</span>
00503 <span class="comment">// ================================================</span>
00504 
00505 <span class="comment">// runes : when a single parm is not enough for a thread</span>
00506 <span class="keyword">struct </span>thread_runes_t { <span class="keywordtype">void</span> *p1,*p2,*p3,*p4,*p5; };
00507 
00510 <span class="keyword">template</span> &lt;<span class="keyword">typename</span> T&gt; <span class="keyword">class </span>atomic_c {
00511 <span class="keyword">public</span>:
00512 
00514         atomic_c() : m() { counter = 0; }
00515 
00517         atomic_c(T value) { counter = value; }
00518 
00520         atomic_c(<span class="keyword">const</span> atomic_c &amp;a) { m.lock(); counter = a.get(); m.unlock(); }
00521 
00523         atomic_c &amp;operator=(atomic_c &amp;a) { <span class="keywordflow">if</span> ((*this) != a) { m.lock(); counter = a.get(); m.unlock(); } <span class="keywordflow">return</span> (*this); }
00524 
00526         atomic_c &amp;operator=(T c) { set(c); <span class="keywordflow">return</span> (*this); }
00527 
00529         <span class="keyword">virtual</span> ~atomic_c() { }
00530 
00532         T get() { T ret; m.lock(); ret = counter; m.unlock(); <span class="keywordflow">return</span> ret; }
00533 
00535         <span class="keywordtype">void</span> set(T value) { m.lock(); counter = value; m.unlock(); }
00536 
00538         <span class="keywordtype">void</span> inc() { m.lock(); counter++; m.unlock(); }
00539 
00541         <span class="keywordtype">void</span> inc_get(T &amp;var) { m.lock(); counter++; var = counter; m.unlock(); }
00542 
00544         <span class="keywordtype">void</span> dec() { m.lock(); counter--; m.unlock(); }
00545 
00547         <span class="keyword">const</span> T&amp; operator++() { inc(); <span class="keywordflow">return</span> counter; }
00548 
00550         <span class="keyword">const</span> T operator++(<span class="keywordtype">int</span>) { T bef; inc(); <span class="keywordflow">return</span> bef; }
00551 
00553   <span class="keyword">const</span> T&amp; operator--() { dec(); <span class="keywordflow">return</span> counter; }
00554 
00556   <span class="keyword">const</span> T operator--(<span class="keywordtype">int</span>) { T bef; dec(); <span class="keywordflow">return</span> bef; }
00557 
00559         <span class="keyword">const</span> T operator==(<span class="keyword">const</span> T &amp;arg) { <span class="keywordflow">return</span> (get() == arg); }
00560 
00562         <span class="keyword">const</span> T operator!=(<span class="keyword">const</span> T &amp;arg) { <span class="keywordflow">return</span> (get() != arg); }
00563 
00565         <span class="keyword">const</span> T operator&gt;(<span class="keyword">const</span> T &amp;arg) { <span class="keywordflow">return</span> (get() &gt; arg); }
00566 
00568         <span class="keyword">const</span> T operator&lt;(<span class="keyword">const</span> T &amp;arg) { <span class="keywordflow">return</span> (get() &lt; arg); }
00569         
00571         <span class="keyword">const</span> T operator&gt;=(<span class="keyword">const</span> T &amp;arg) { <span class="keywordflow">return</span> (get() &gt;= arg); }
00572 
00574         <span class="keyword">const</span> T operator&lt;=(<span class="keyword">const</span> T &amp;arg) { <span class="keywordflow">return</span> (get() &lt;= arg); }
00575 
00576 <span class="keyword">protected</span>:
00577         T counter;      <span class="comment">//protected object</span>
00578         mutex_c m;      <span class="comment">//mutex for accessing the object</span>
00579 };
00580 
00582 <span class="keyword">typedef</span> atomic_c&lt;int&gt; atomic_counter_c;
00583 
00584 <span class="preprocessor">#endif // NO_DOXYGEN</span>
00585 <span class="preprocessor"></span>
00586 <span class="preprocessor">#endif // _THREAD_H_</span>
00587 <span class="preprocessor"></span>
</pre></div><hr><address style="align: right;"><small>Generated on Mon Jan 24 21:14:23 2005 for ZIG by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border=0 
width=110 height=53></a>1.2.18 </small></address>
</body>
</html>