שלום לך

קיבלתי תרגיל תיכנותי ב#C ואין לי את הכלים לעשות אותו ( אף פעם לא עבדתי על התוכנה הזאת )

אם מישהו יוכל לתת לי פתרון חלקי או הנחיות איך לפתור את התרגיל הזה .

תודה על העזרה

תכנות בעצמים מבוזרים

עליך לכתוב מערכת ובה שרת ראשי (להלן ראשי) ומספר לקוחות. כל לקוח פונה לראשי עבור סוג פעולה אחד: העלאת מספר בחזקת השני. הראשי מפעיל מספר threads, באשר כל אחד עובד מול לקוח אחר. עבודה אופיינית נראית כך:

הלקוח וה (thread הפרטי שלו ב) שרת יוצרים קשר.

הלקוח מגריל מספר שלם m בין 3 ל-10; זהו מספר פעולות החשוב שיבקש.

מתחילה לולאה לפיה (שוב, במלה שרת הכוונה לנים המתפקד כשרת עבור לקוח מסוים, ובמלה ראשי הכוונה ל-thread הראשי בצד השרת):

o הלקוח מגריל זוג מספרים שלמים (x,y) ושולח אותם לשרת,

o השרת מחשב את x^y ומחזיר ללקוח,

o הלקוח ממתין זמן-מה באלפיות שנייה: בין 3000 ל-10000,

o וחוזר חלילה, עד m.

מבנה המידע:

o כאשר הלקוח מבקש חשוב, הוא שולח קבוצת נתונים (חפיסה, בלשון תקשורת) המורכבת מהמספר 1 (שפירושו חשוב) ומשני מספרים שהם ה-x וה-y. לדוגמא: 1 5 8

o כאשר הלקוח מבקש לסיים את הקשר (כי הוא כבר בקש m חשובים) הוא שולח חפיסה שהמספר הראשון בה הוא 0 (שפירושו סיום חשוב) ושני מספרים נוספים, כדי שהחפיסה תהיה באותו גדל כמו חפיסת חשוב. לדוגמא: 0 0 0

o חפיסת המידע שהשרת שולח ללקוח פשוטה יותר: מספר יחיד שהוא התשובה.

הראשי מוכן להפעיל לכל היותר שלושה threads כשרתים מול לקוחות. כאשר שלושתם עסוקים ומתקבלת פניה נוספת, הוא שומר אותה בתור. נניח שהתור הוא בגדל של 10 .

שרת שהלקוח שלו סיים לעבוד מולו, מסים אף הוא. הראשי צריך לדעת על כך (כדי שיצור שרת נוסף, כל עוד יש פחות מ-3 פעילים).

מה זאת אומרת "אף פעם לא עבדתי על התוכנה הזאת"?

מעולם לא כתבת ב-#C, ומצפים ממך לפתור תרגיל על נושא מתקדם כמו ת'רדים?

כן פשוט ככה

כמה דוגמאות קטנות בכיתה

וישר תרגיל תיכנותי

אם יש לך ספרות (עם יש בעברית יותר טוב) שתעזור לי אני מאוד ישמח

האם לפחות אתה מכיר multithreading בפלרפורמות אחרות? Java, Posix, משהו?

קיבלתי קצת רקע על תרדים גם בJAVA

איך אני יוצר שרת אשר יוצר 3 תרדים לעבודה ועוד תור של המתנה של 10 זאת אומרת יכולים לרוץ 3 תרדים ןברגע שהתרד מסיים לרוץ השרת צריך לדעת זאת כדי לתת לממתין בתור להיכנס לפעולה.

אם השאר אני ינסה כבר להתמודד

קיבלתי קצת רקע על תרדים גם בJAVA

איך אני יוצר שרת אשר יוצר 3 תרדים לעבודה ועוד תור של המתנה של 10 זאת אומרת יכולים לרוץ 3 תרדים ןברגע שהתרד מסיים לרוץ השרת צריך לדעת זאת כדי לתת לממתין בתור להיכנס לפעולה.

אם השאר אני ינסה כבר להתמודד

יש לך את המשתנה של המחלקה

Thread.IsAlive

כל זמן שהוא שווה ל true הת'רד פועל

ונכון להפך

תאמת, לא שאלה קשה, אבל חייב רקע, לפחות רקע מינימלי בסוקטים, בעבודה עם ריבוי משימות

קיבלתי קצת רקע על תרדים גם בJAVA

איך אני יוצר שרת אשר יוצר 3 תרדים לעבודה ועוד תור של המתנה של 10 זאת אומרת יכולים לרוץ 3 תרדים ןברגע שהתרד מסיים לרוץ השרת צריך לדעת זאת כדי לתת לממתין בתור להיכנס לפעולה.

אם השאר אני ינסה כבר להתמודד

אתה יכול להקפיץ event מהthread,ושהשרת יאזין לו ויפעל בהתאם.

עקרונית, ללא בקרת שגיאות זה מאוד פשוט.

אני מניח שהחלק הבעייתי יותר הוא השרת:

  public class Server
  {

    ArrayList _pending;
    int _intProcessing;


    public Server()
    {
      _intProcessing = 0;
      _pending = new ArrayList();


    }

    public void Start()
    {
      TcpListener _listener = new TcpListener(10000);

      while (true)
      {
        if (_pending.Count < 10)
        {
          try
          {
            TcpClient _newClient = _listener.AcceptTcpClient();
            if (_newClient.Connected)
            {
              if (_intProcessing < 3)
                ProcessClient(_newClient);
              else
                _pending.Add(_newClient);
            }
          }
          catch (Exception e)
          {

          }
        }

        Thread.Sleep(1000);
        if ((_pending.Count > 0) && (_intProcessing < 3))
        {
          TcpClient _newClient = (TcpClient)_pending[0];
          _pending.RemoveAt(0);
          ProcessClient(_newClient);
        }
      }
    }

    private void ProcessClient(TcpClient _newClient)
    {
      ConnectedClient _newConnectedClient = new ConnectedClient(_newClient);
      _newConnectedClient.OnDone+= new ConnectedClient.DoneProcessingDelegate(_newConnectedClient_OnDone);
      Thread _t = new Thread(new ThreadStart(_newConnectedClient.Run));
      Interlocked.Increment(ref _intProcessing);
    }

    private void _newConnectedClient_OnDone()
    {
      Interlocked.Decrement(ref _intProcessing);
    }


  }

  public class ConnectedClient
  {

    TcpClient _client;
    NetworkStream _stream;

    public delegate void DoneProcessingDelegate();
    public event DoneProcessingDelegate OnDone;

    public ConnectedClient(TcpClient _client)
    {
      this._client = _client;
      _stream = _client.GetStream();
      _stream.ReadTimeout = -1;
    }

    public void Run()
    {
      string _strBuffer = "";
      byte[] _buffer = new byte[_client.ReceiveBufferSize];

      while (_strBuffer != "0 0 0")
      {
        try
        {
          int _intResult = _stream.Read(_buffer, 0, _buffer.Length);
          if (_intResult > 0)
          {
            //Check if not exit condition, Do the calculation here and write the result back to the stream.
          }
        }
        catch (Exception e)
        {
          _strBuffer = "0 0 0";
          Console.WriteLine(e.Message);
        }

      }

      if (OnDone != null)
        OnDone();
    }

  }