שימוש במשאבי המערכת

מבוא

סטודנטים בקורס הקדמה לתכנות Java אחראים לידיעת והבנת כל החומר בשעור זה

 (חוץ מנושאים ספציפיים ב – C++).

הנושאים הספציפיים ב – C++ מוצעים כחומר משלים לטובת אלו שמכירים כבר C++

ומבצעים הסבה ל – Java.

הקדמה

לעתים התוכנית שלך תזדקק לגישה למשאבי שונים של המערכת כגון זרימת קלט/פלט, השעון, וכו'.

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

מחלקת System חברה בחבילה java.lang. הקטע הבא מציג את ההצהרות על שדות ומתודות הנכללים במחלקת System.

public  final  class  java.lang.System
    extends  java.lang.Object 
{
// Fields
public static PrintStream err; 
public static InputStream in;  
public static PrintStream out; 

// Methods
public static void arraycopy(
  Object  src, int  src_position,
  Object  dst, int  dst_position, int  length);
public static long currentTimeMillis();
public static void exit(int  status); 
public static void gc(); 
public static Properties getProperties(); 
public static String getProperty(String  key); 
public static String getProperty(
  String  key, String  def);
public static SecurityManager getSecurityManager(); 
public static void load(String  filename); 
public static void loadLibrary(String  libname);  
public static void runFinalization();
public static void setProperties(Properties  props); 
public static void setSecurityManager(
  SecurityManager  s); 
}

תוכל לזהות, שבכמה מהן השתמשנו כבר בשיעורים קודמים –
למשל, out, in, exit(), currentTime(), getProperties().
בחלק המקרים, השתמשנו בחברים אלה מבלי להבין בדיוק מה אנו עושים.

בשיעור זה ננסה להבין.

שימוש במחלקת System

כדי להשתמש במחלקת System איננו יוצרים אובייקטים, משום שכל המשתנים והמתודות שלה הם משתני מחלקה ומתודות מחלקה.

למעשה, לא ניתן ליצור אובייקטים של מחלקת System. זוהי מחלקה המצוינת כ‑final,
וכל הבנאים שלה מוגדרים כ‑private.
זו הסיבה לכך שבטבלה לא רואים את אוסף הבנאים, כמקובל.

כזכור, על מנת לגשת למשתנה מחלקה או למתודת מחלקה, עליך פשוט לצרף את שמם לשם המחלקה, כשהם מופרדים בנקודה, באופן הבא:

System.out.println("my string");

הגישה למתודות מחלקה נעשית באופן דומה.
באחד השיעורים הקודמים השתמשנו בקטע הקוד הבא כדי להחזיר את מאפייני ברירת המחדל של המערכת, אשר מועברים לבנאי על מנת לאחסן אותם באובייקט Properties:

System.getProperties()

מומלץ שתחזור לשיעור ההוא ותעיין בתוכנית בשנית.

זרימת קלט/פלט סטנדרטי

שיעור חשוב בעתיד ידון בזרימת קלט/פלט. כאן ניגע בנושא זה רק מבחינת מה שקשור לשימוש במחלקת System.

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

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

מחלקת System מנהלת שלוש זרימות קלט ופלט סטנדרטיים:

·       קלט סטנדרטי, שעליו מצביע System.in

·       פלט סטנדרטי, שעליו מצביע System.out

·       שגיאה סטנדרטית, שעליה מצביעה System.err

הזרימות הללו נפתחות ומקושרות אוטומטית להתקנים כאשר מתחיל ביצוע התוכנית.

מתודות print(), println(), write()

משתני המחלקה out ו‑err הם מטיפוס PrintSream, כלומר הם בעלי גישה למתודות של מחלקת PrintSream. PrintSream מספקת שלוש מתודות על מנת להדפיס טקסט לתוך הזרימה:

·       ()print

·       ()println

·       ()write

שתי המתודות הראשונות כבר מוכרות לך. העובדה שהמתודות הללו זמינות במחלקת PrintSream, מאפשרת לך לכתוב הוראות כגון

System.out.write(...);

המתודות ()print ו‑()println זהות, מלבד העובדה, ש‑()println מציבה אוטומטית בזרימה שורה חדשה בסוף רשימת הארגומנטים.

המתודה ()write משמשת כדי לכתוב בייטים אל הזרימה. תוכל להשתמש ב‑()write כדי לכתוב נתונים שלא נועדו להתפענח כטקסט (כגון נתוני גרפיקה בשיטת מיפוי סיביות).

ארגומנטים עבור ()print ו‑()println

המתודות ()print ו‑()println מקבלות שתיהן ארגומנט יחיד מכל אחד מהטיפוסים הבאים:

·       Object

·       String

·       char[]

·       int

·       long

·       float

·       double

·       boolean

בכל אחד מן המקרים, המערכת ממירה את הנתונים לאוסף תווים מתאים ומעבירה את התווים הללו להתקן הפלט הסטנדרטי.

כאשר אתה מפעיל את ()println ללא ארגומנטים, המתודה פשוט מכניסה לזרימה שורה חדשה.

הדפסת אובייקטים מטיפוסי נתונים שונים

כפי שאתה כבר יודע, ניתן להשתמש במתודת ()println על מנת לתרגם משתנה מטיפוס פרימיטיבי כלשהו לערך התו, המייצג אותו, ולהציג אותו בהתקן הפלט הסטנדרטי.

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

System.out.println(objectData);

 יציגו פלט כזה:

Thread[Thread-4,5,main] 

מתודת toString, גם בגירסאות מועמסות שלה, משמשת להמרת אובייקטים לייצוג String.

כשאתה משתמשת במתודות ()print או ()println כדי להדפיס אובייקט, הפלט יהיה תלוי בטיפוס של אותו אובייקט. לדוגמה, הדפסה של אובייקט String מציגה את תוכן ה‑String. הדפסה של אובייקט Thread יוצרת מחרוזת-פלט בפורמט כזה:

ThreadClass[name,priority,group]

אובייקטֵי Thread ידונו באחד השיעורים הבאים.

מאפייני המערכת

בשיעור קודם למדנו שמאפיינים הם צמדים של key/value, שבהם תוכל התוכנית שלך להשתמש על מנת לקבוע ולנהל אטריבוטים או פרמטרים שונים, מהפעלה אחת לאחרת של התוכנית.

סביבת Java מנהלת גם קבוצה של מאפייני מערכת, המכילים מידע לגבי הסביבה הנוכחית.
כפי שהדגמנו באחד השיעורים הקודמים, ניתן לגשת למאפייני המערכת באמצעות מחלקת System. קבוצת המאפיינים הזו מגדירה את התכונות של סביבת העבודה הנוכחית.

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

להלן פלט של הפרמטרים של המערכת שלי, כפי שהוצגו בשיעור קודם:

-- listing properties --
user.language=en
java.home=C:\JAVA_JDK\JAVA\BIN\..
awt.toolkit=sun.awt.windows.WToolkit
file.encoding.pkg=sun.io
java.version=1.1.3
file.separator=\
line.separator=

user.region=US
file.encoding=8859_1
java.vendor=Sun Microsystems Inc.
user.timezone=CST
user.name=Baldwin
os.arch=x86
os.name=Windows 95
java.vendor.url=http://www.sun.com/
user.dir=C:\BALDWIN\JavaProg\Combined\Java
java.class.path=.;c:\Baldwin\JavaProg;C:\JAVA_JDK\JAV...
java.class.version=45.3
os.version=4.0
path.separator=;
user.home=C:\JAVA_JDK\JAVA\BIN\..

מחלקת System מספקת מספר מתודות לצורך קריאה וכתיבה של מאפייני המערכת. ניתן לגשת אליהם אחד-אחד באמצעות שם ה‑key, וניתן גם לקרוא את כל קבוצת המאפיינים בהוראה אחת,
כפי שעשה זאת הקוד למעלה.

שיקולי בטיחות ביחס למאפייני מערכת

נכון לזמן הכתיבה (27/1/97), applets מסוגלים לגשת לכמה ממאפייני המערכת, אך לא לכולם.
כמו כן, applets אינם יכולים לכתוב לתוך מאפייני המערכת. מבחינה זו, בחודשים הקרובים צפויים שינויים משמעותיים. אנו נדון בכך בהמשך.

קריאת מאפייני המערכת

מחלקת System מספקת שתי מתודות לצורך קריאת מאפייני המערכת:

·       getProperty()

·       getProperties()

אם תעיין שנית בהצהרות על המחלקות, שהופיעו בתחילת השיעור, תמצא שישנן שתי גירסאות מועמסות של getProperty().

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

שתי הגירסאות מחזירות אובייקט מטיפוס String. שמות כל ה‑keys הסטנדרטיים מופיעים בטבלה, שהובאה קודם ומראה את הערכים המיוחסים לכל key במחשב שלי ברגע מסוים בזמן.

במידה ואחת המתודות אינה מסוגלת למצוא את ה‑key, היא תחזיר הצבעה בעלת הערך null.

הגירסה המועמסת השנייה של מתודת getProperty() מחייבת שתי מחרוזות כארגומנטים. הארגומנט הראשון הוא ה‑key שעליה לחפש, והארגומנט השני הוא ערך ברירת מחדל,
שאותו תחזיר המתודה אם ה‑key לא יימצא, או אם אין לו ערך.

מתודה שלישית, שמספקת מחלקת System על מנת לגשת למאפייני המערכת, היא מתודת getProperties(). המתודה מחזירה אובייקט Properties המכיל את כל קבוצת המאפיינים של המערכת כצמדים של key/value. זו המתודה שבה השתמשנו באחד השיעורים הקודמים על מנת להציג רשימה מלאה של מאפייני המערכת, כפי שזו הובאה למעלה.

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

כמו כן, תוכל להשתמש באחת המתודות של מחלקת Properties על מנת להציג רשימה מלאה של המאפיינים. אפשרות כזו נדונה, כאמור, בשיעור קודם.

כתיבה לתוך מאפייני מערכת

תוכל לשנות את מאפייני המערכת הקיימים תוך שימוש במתודת setProperties() של מחלקת System.

מתודה זו מקבלת אובייקט Properties, שאותחל כך שהוא יכיל את הצמדים key/value שברצונך לקבוע.
המתודה מחליפה את כל קבוצת מאפייני המערכת בקבוצה חדשה שמיוצגת על ידי האובייקט הנ"ל.

עקרונית, עליך להיות זהיר מאוד בכתיבה לתוך מאפייני המערכת.

מתודת setProperties() משנה את קבוצת מאפייני המערכת עבור האפליקציה שרצה באותו זמן בלבד.

מערכת זמן ריצה מאתחלת מחדש את מאפייני המערכת בכל פעם שהיא מופעלת.

לכן, שינויים שנעשו באמצעות setProperties() אינם קבועים.

שינוי מאפייני המערכת במסגרת אפליקציה אחת, לא ישפיע על המפענח של Java כשהוא יופעל בעתיד עבור אותה אפליקציה, או עבור אפליקציות אחרות.

אם ברצונך שהשינויים במאפייני המערכת יהיו קבועים, האפליקציה שלך צריכה לשמור את הערכים לתוך קובץ לפני היציאה, ולהטעין אותם שוב בהפעלה הבאה.

מחלקת Properties מספקת מתודות לצורך שמירת וטעינת אובייקט של מאפייני המערכת.

אילוץ (בקשת) ביצוע סיום ואיסוף אשפה

כל האובייקטים ב‑Java נוצרים בזמן ריצה באופן דינאמי על ה‑heap. כל אימת שאין יותר משתנים, המצביעים על אובייקט, האובייקט יהיה מוּעָד לאיסוף אשפה.

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

מתודת finalize() של אובייקט תבוצע תמיד לפני שהזיכרון, שתפס האובייקט,
נתבע על ידי אוסף האשפה.

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

על פי The Java Tutorial by Campione & Walrath:

"ניתן לאלץ את אוסף האשפה לרוץ באמצעות המתודה gc() של מחלקת System.
כמו כן, ניתן לאלץ את מערכת זמן-ריצה לבצע סיום של אובייקטים באמצעות המתודה runFinalization()."

הן מציינות גם כי:

" המתודה runFinalization() קוראת למתודות finalize() עבור כל האובייקטים הממתינים לאיסוף אשפה."

במקום אחר הן מציינות כי:

"ניתן לבקש מאוסף האשפה לרוץ בכל זמן, באמצעות קריאה למתודת gc() של מחלקת System."

האבחנה כאן היא בין "לאלץ את אוסף האשפה לרוץ" לבין "לבקש מאוסף האשפה לרוץ".

המתודה הבאה נוספה למחלקת System ב‑1.1 JDK:

runFinalizersOnExit(boolean).

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

על מנת להבטיח את סיום האובייקטים ביציאה, עליך לקרוא למתודה זו ולהעביר לה ערך "אמת" במקום כלשהו בתוכנית.

מבין שלוש המתודות, הנוגעות לביצוע סיום ואיסוף אשפה, היחידה האמינה בעיניי היא runFinalizersOnExit(boolean).

System.runFinalization() ו‑System.gc() אינן מתנהגות כפי שהייתי מצפה מהן.

ואומנם, בתיעוד של JavaSoft מצוין כי שתי המתודות רק "מציעות" ל‑JVM "להשקיע את מירב המאמצים" כדי לעשות את מה שביקשת (ביצוע סיום או איסוף אשפה).

מתכנתי ++C צריכים להיות מודעים לכך, שביצוע סיום ואיסוף אשפה אינם מקבילים לפעולת השמדן ב‑++C.
דיון מעולה בנושא תוכל למצוא בספרו העומד לצאת לאור של Bruce Eckel: Thinking in Java. באחד השיעורים הקודמים ניתן ה‑URL, שבו תוכל לעיין בטיוטה של הספר באופן מקוון,
או להוריד אותו למחשב שלך.

מתודות שונות של מחלקת System

עיון ברשימת ההצהרות של מחלקת System, שהובאה בתחילת השיעור,
מגלה שבמחלקה זו קיים מיגוון של מתודות נוספות.

העתקת מערך

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

public static void arraycopy(Object src, int src_position,
                Object dst, int dst_position, int length);

שני ארגומנטים מטיפוס Object מציינים את מערך-המקור ואת מערך-היעד.

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

את מערך היעד יש להקצות לפני הקריאה ל‑arraycopy(), ועליו להיות גדול דיו כדי להכיל את הנתונים שיועתקו לתוכו.

יציאה מסביבת זמן-ריצה

ניתן לצאת מהמפענח של Java באמצעות קריאה ל‑System.exit() ולהעביר לה כפרמטר קוד יציאה מטיפוס integer. שים לב, שלא כל מערכות ההפעלות מתייחסות לקוד היציאה.

שיקולי בטיחות ביחס ל‑System.exit()

על פי The Java Tutorial:

"הפעלת המתודה exit() כפופה למגבלות בטיחות. בהתאם לדפדפן שבו רץ ה‑applet, סביר שקריאה ל‑exit() מתוך ה‑applet תגרום לזריקת SecurityException."

שיקולי בטיחות כלליים

על פי Campione & Walrath