א פְּתִיל ב-Java יכול להתקיים בכל אחד מהמצבים הבאים בכל זמן נתון. שרשור נמצא רק באחד מהמצבים המוצגים בכל רגע:

1. מדינה חדשה
2. מדינה ניתנת להפעלה
3. מדינה חסומה
4. מצב המתנה
5. מצב המתנה מתוזמן
6. מדינה שהופסקה

התרשים שלהלן מייצג מצבים שונים של חוט בכל רגע:

מחזור חיים של חוט 

ישנם מצבים מרובים של החוט במחזור חיים כפי שהוזכר להלן:

1. שרשור חדש: כאשר נוצר שרשור חדש הוא נמצא ב- מדינה חדשה . השרשור עדיין לא התחיל לפעול כשהשרשור במצב זה. כאשר שרשור נמצא במצב החדש הקוד שלו עדיין לא מופעל ולא התחיל לפעול.
2. מדינה ניתנת להפעלה : חוט כלומר מוכן לרוץ מועבר למצב שניתן להפעיל. במצב זה יתכן שרשור באמת פועל או שהוא מוכן להפעלה בכל רגע של זמן. באחריות מתזמן השרשור לתת לשרשור זמן לרוץ. תוכנית מרובת חוטים מקצה פרק זמן קבוע לכל חוט בודד. כל חוט וחוט מקבל כמות קטנה של זמן לרוץ. לאחר ריצה לזמן מה שרשור עוצר ומוותר על המעבד כדי ששרשורים אחרים יוכלו לרוץ.
3. חָסוּם: השרשור יהיה במצב חסום כאשר הוא מנסה לרכוש מנעול אבל כרגע המנעול נרכש על ידי החוט השני. השרשור יעבור ממצב חסום למצב בר הפעלה כאשר הוא ירכוש את הנעילה.
4. מצב המתנה : השרשור יהיה במצב המתנה כאשר זה קורא wait() שיטה או לְהִצְטַרֵף() שִׁיטָה. זה יעבור למצב שניתן להרצה כאשר שרשור אחר יודיע או שרשור זה יסתיים.
5. המתנה מתוזמנת : חוט נמצא במצב המתנה מתוזמן כאשר הוא קורא לשיטה עם פרמטר פסק זמן . שרשור נמצא במצב זה עד להשלמת הזמן קצוב או עד קבלת הודעה. לדוגמה, כאשר שרשור קורא שינה או המתנה מותנית הוא מועבר למצב המתנה מתוזמן.
6. מדינה שהופסקה: שרשור מסתיים בגלל אחת מהסיבות הבאות: 
   
   • כי זה יוצא כרגיל. זה קורה כאשר הקוד של השרשור הופעל לחלוטין על ידי התוכנית.
   • מכיוון שהתרחש אירוע שגוי יוצא דופן כמו תקלת פילוח או חריג לא מטופל.

שרשור מדינות בג'אווה

ב-Java כדי לקבל את המצב הנוכחי של השרשור השתמש Thread.getState() שיטה לקבל את המצב הנוכחי של השרשור. Java מספקת Java.lang.Thread.State enum שמגדיר את קבועי ENUM עבור מצב השרשור כסיכום שלו ניתן להלן: 

1. חדש 

מצב שרשור עבור שרשור שעדיין לא התחיל. 

שרשור סופי סטטי ציבורי. מצב חדש

2. ניתן להרצה 

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

שרשור סופי סטטי ציבורי. מצב ריצה

3. חסום 

מצב שרשור עבור חוט חסום בהמתנה לנעילת צג. שרשור במצב חסום ממתין לנעילת מוניטור להיכנס לבלוק/שיטה מסונכרנת או להזין מחדש בלוק/שיטה מסונכרנת לאחר קריאה Object.wait(). 

שרשור סופי סטטי ציבורי. מצב חסום

4. מחכה 

 מצב שרשור עבור שרשור ממתין. שרשור נמצא במצב המתנה עקב קריאה לאחת מהשיטות הבאות: 

• Object.wait ללא פסק זמן
• Thread.join ללא פסק זמן
• LockSupport.park

שרשור סופי סטטי ציבורי. מדינה ממתין

5. המתנה מתוזמנת 

מצב שרשור עבור שרשור המתנה עם זמן המתנה מוגדר. שרשור נמצא במצב המתנה מתוזמן עקב קריאה לאחת מהשיטות הבאות עם זמן המתנה חיובי מוגדר: 

• חוט.שינה
• Object.wait עם פסק זמן
• Thread.join עם פסק זמן
• LockSupport.parkNanos
• LockSupport.parkUntil

שרשור סופי סטטי ציבורי. מצב TIMED_WAITING

6. הסתיים 

מצב שרשור עבור שרשור שהסתיים. השרשור סיים את הביצוע. 

שרשור סופי סטטי ציבורי. מצב סיום

דוגמה להדגמת מדינות שרשור

להלן דוגמה מהעולם האמיתי של מערכת הזמנת כרטיסים המדגימה מצבי שרשור שונים:

דוּגמָה:

   // Java program to demonstrate thread states    // using a ticket booking scenario   class   TicketBooking     implements     Runnable     {      @Override      public     void     run  ()     {          try     {          // Timed waiting      Thread  .  sleep  (  200  );         }     catch     (  InterruptedException     e  )     {      e  .  printStackTrace  ();      }      System  .  out  .  println  (  'State of bookingThread while mainThread is waiting: '     +      TicketSystem  .  mainThread  .  getState  ());      try     {          // Another timed waiting      Thread  .  sleep  (  100  );         }     catch     (  InterruptedException     e  )     {      e  .  printStackTrace  ();      }      }   }   public     class   TicketSystem     implements     Runnable     {      public     static     Thread     mainThread  ;      public     static     TicketSystem     ticketSystem  ;      @Override      public     void     run  ()     {      TicketBooking     booking     =     new     TicketBooking  ();      Thread     bookingThread     =     new     Thread  (  booking  );      System  .  out  .  println  (  'State after creating bookingThread: '     +     bookingThread  .  getState  ());      bookingThread  .  start  ();      System  .  out  .  println  (  'State after starting bookingThread: '     +     bookingThread  .  getState  ());      try     {      Thread  .  sleep  (  100  );      }     catch     (  InterruptedException     e  )     {      e  .  printStackTrace  ();      }      System  .  out  .  println  (  'State after sleeping bookingThread: '     +     bookingThread  .  getState  ());      try     {          // Moves mainThread to waiting state      bookingThread  .  join  ();         }     catch     (  InterruptedException     e  )     {      e  .  printStackTrace  ();      }      System  .  out  .  println  (  'State after bookingThread finishes: '     +     bookingThread  .  getState  ());      }      public     static     void     main  (  String  []     args  )     {      ticketSystem     =     new     TicketSystem  ();      mainThread     =     new     Thread  (  ticketSystem  );      System  .  out  .  println  (  'State after creating mainThread: '     +     mainThread  .  getState  ());      mainThread  .  start  ();      System  .  out  .  println  (  'State after starting mainThread: '     +     mainThread  .  getState  ());      }   }   

תְפוּקָה:

הֶסבֵּר:

• כאשר נוצר שרשור חדש השרשור נמצא במצב NEW. כאשר השיטה start() נקראת על שרשור, מתזמן השרשור מעביר אותו למצב Runnable.
• בכל פעם שמתודה join() נקראת על מופע של שרשור, השרשור הראשי עובר ל-Witing to the booking threaded to complete.
• לאחר ששיטת הריצה של השרשור מסתיימת מצבו הופך ל-Terminated.