אני יצרתי THREAD שיש בתוכו לופ עד שהתוכנית נגמרת והכל עובד טוב אבל יש לי בעיה שאני בודק בTASKMANAGER אני רואה שהתרד עושה שיהיה CPU USAGE מעל 50% ואני רוצה לדעת איך מתקנים את זה שיהיה CPU USAGE נורמלי זה הפונקציה של התרד:

   private void MainThread()
    {
      while (!isDisposed)
      {
        System.Diagnostics.Debug.WriteLine("Main Thread is active");
      }

    }

איזו סיבה יש לו לא להיות על כמה שיותר CPU?

כל עוד אין תוכניות אחרות שמבקשות משאבים, אז מערכת ההפעלה תקצה את כל המשאבים שהיא יכולה למי שכן מבקש (הת'רד שלך).

אם אתה רוצה שהת'רד "יירגע" לפעמים וייקח הפסקות, אתה צריך להשתמש בפונקציות שגורמות לו לחכות - sleep או wait.

הסיבה שהוא על 50% זה כי יש לך מעבד כפול ליבה, אז הוא רק יכול לתפוס חצי ממנו לכל היותר.

אני רוצה ליצור תרד שיחכה עד שייתקבל מידע מלקוח(ב SOCKET) ואז יפעל אני לא רוצה להשתמש בASYNC SOCKET כי אז זה יפתח תרד לכל CLIENT

אני משתמש ב

Socket.BeginRecive

אז איך עושים את זה בלי זה ?

איך אתה יכול לבדוק את האחוז CPU של thread בודד?

מה שאתה רואה בtask manager הוא שימוש במעבד של כל הפורסס של האפליקציה שלך.

אגב, אתה צריך לתת לthread הזה משהו שיגרום לו לחכות קצת, שלא סתם ירוץ ויקבל זמן מעבד.

לתת לו sleep של כמה רגעים בכל איטרציה של הלולאה לדוגמא. אחרת עלול להיוורצ מצב שבוא הוא פשוט יתפוס 100% מהמעבד שלך, ושום דבר אחר לא יקרה, והכל יקפא.

לצערי אני לא כל כך מבין ב-socketים, אז אני לא יכול לעזור לך בזה.

אבל אני לא מבין, מה רע בזה שיפתח ת'רד לכל client?

לצערי אני לא כל כך מבין ב-socketים, אז אני לא יכול לעזור לך בזה.

אבל אני לא מבין, מה רע בזה שיפתח ת'רד לכל client?

עומס

בכל מקרה לא אמור להפתח לך ת'ראד על כל קליינט שמתחבר, תוריד proccess xp ותבדוק בדיוק איזה ת'ראדים התוכנה פותחת לך.

הסיבה שמה שעשית תופס כלכך הרבה מעבד זה כי אתה מריץ את זה בלולאה אחת כל הזמן.

מה שאתה רוצה לעשות בערך זה ככה:

 static public void MyThread()
    {
/* do some shit*/
MessageBox.Show("this is my thread);
Thread.Sleep(0);

    }

עכשיו בפונקציה נוספת אתה מטפל בEvent שאומר שנפתח סוקט התחבר קליינט לא משנה מה אני ממה לא יודע איך אתה כותב את זה, ברגע שהEvent הזה קרה, אתה כותב בפונקציה נפרדת את

Thread newThread = new Thread(new ThreadStart(ThreadProc));
newThread.start();
Thread.Sleep(0);

ואז זה "מריץ" את MyThread כמו מתודה "וסוגר"(הת'ראד הולך לישון פשוט הוא עדיין תכלס קיים, יש הרבה כתבות על למה כל תוכנה שמשתמשת בזה היא תכונה גרועה אבל זה רק להדגמה, להכניס כאן abort/switch וכו' וכו' פשוט היה דורש עוד דיי הרבה שורות קוד) את הThread שלה אחרי הפעולה, זהו בעקרון כמובן שזה על רגל אחת, אם כבר עושים תוכנה באמת יעילה אז צריך לחלק את כל התוכנה לת'ראדים נפרדים רק שים לב לדבר אחד וזה מאוד חשוב לכל תוכנה לא משנה אם אתה משתמש בזה או לא יש דבר שנקרא Main Thread עד שהוא לא מוותר על זמן המעבד במעבד שהוא uniproccessor שום Thread אחר לא יקבל זמן מעבד וזה מוביל לlockups.

אין אוונט שמופעל ברגע שמישהו שולח מידע בכל מקרה השתמשתי IDLE האם זה טוב עכשיו הCPU USAGE נורמלי עכשיו יש לי עוד בעיה

בSOCKET שאני שולח מידע הוא לא באמת שולח אותו הוא מחכה לבדוק אם אני ישלח מידע עוד פעם ואז שולח את המידע ששלחתי בפעם הראשונה עם המידע ששלחתי בפעם השניה ואם אני לא מנסה לשלוח עוד מידע אחרי כמה שניות הוא שולח את המידע .

עכשיו זה יכול לגרום לבעיה בפענוח המידע וגם בזמן כי בתוכנית שאני בונה אני רוצה שברגע שישלח מידע הוא יגיע הכי מהר שאפשר אז איך אני גורם לכך שישלח מידע בדיוק אחרי שאני קורא לSEND? ניסיתי לשנות את המאפיין NODELAY לTRUE אבל זה רק הופך את הפעולה למהירה יותר אבל זה עדיין לא נשלח בדיק אחרי שאני

קורא לפונקציה SEND איך מתקנים את זה?

TCP לא בדיוק מבטיח שליחה מהירה. יש הרבה אלגוריתמים מאחורי הקלעים שגורמים לכך שמידע שנשלח לא בהכרח (למעשה בדרך כלל לא) נשלח מיידית. מהבחינה הזו עדיף UDP. גם מידע שנשלח לא הכרח יגיע מיידית לשכבת האפליקציה בצד השני.

בד"כ יש כל מני פרמטרים האפשרים שליחה מהירה, וגם שמים את הדגל URGENT שאמור לגרום להעברה מהירה של המידע לצד השני.

לגבי המתנה למידע, נשמע לי שאתה צריך פשוט קריאה חוסמת רגילה (synchronous / blocking read).

אולי Receive במקום BeginReceive? (זה סתם ניחוש)

אני פתרתי את הבעיה של הRECIVE הבעיה היא בSTREAM אבל אני יבנה את השרת ככה שהוא ידע לטפל בשני בקשות בשליחה אחת

רק איך אני יכול לקבוע את הגודל המקסימלי של מידע שנשלח כי גודל המערך אצל השרת שמקבל את ההודעה הוא 100

עריכה: האם כדאי להשתמש בUDP בשביל משחקים

Socket.SendBufferSize

בכל מקרה אתה רוצה לעבוד עם Async Soket אחרת זה כאב ראש גדול, וגם מבחינת ביצועים זה טוב בהרבה. תעשה שהקליינט פותח סוקט אחד תמידי שזה הheartbeat מול השרת, ומעביר מידע בAsync כל פעם השרת יפתח ת'ראד ויסגור אותו מה בדיוק הבעיה? ראית את כמות הthreadים שתוכנות פותחות?

זה עדיף מלשמור טריליון סוקטים, לריב עם timeoutים ועוד הרבה דברים אחרים.

אז עדיף להשתמש ב5000 תרדים לכל קליינט במקום בתרד אחד לכולם?

ולא עניתי מה עדיף UDP או TCP למשחקים של RT

שניהם מידע חשוב עובד בTCP כל השאר בUDP שוב הכל שאלה של איזה משחק זה בלי לדעת שום דבר אי אפשר לענות לך.

ושוב זה לא פותח, זה פותח וסוגר ישר גם את הת'ראד וגם את הסוקט, תקשורת בAsync מהירה יותר אבל הרבה יותר מסובך להרכיב את הפלטפורמה בצורה נכונה.

אני רוצה ליצור תרד שיחכה עד שייתקבל מידע מלקוח(ב SOCKET) ואז יפעל אני לא רוצה להשתמש בASYNC SOCKET כי אז זה יפתח תרד לכל CLIENT

אני משתמש ב

Socket.BeginRecive

אז איך עושים את זה בלי זה ?

זו הצורה הכי טובה. *IOCP*

תיצור windows service זה יהיה ה-listener שלך..

הוא יאזין באמצעות wcf. ה-client יוכל לשלוח תשובה מתי שהוא רוצה.

WCF כבר יטפל לך בכל ה-overhead המיותר.

אני לא רוצה להשתמש בWindows Service והחלטתי להשתמש ב IOCP אבל משום מה אני לא מצליח לקשר בין הSocket לIOCP