Thread synchronization is a potenti

Thread synchronization is a potential performance problem in many Java programs that use multithreading. Since Java libraries are implemented in a thread-safe manner, the performance of even singlethreaded applications may be degraded due to synchronization. In Java, synchronization is provided through monitors, which are language-level constructs used to guarantee mutually-exclusive access to shared data-structures [Silberschatz and Galvin 1997]. Unfortunately, monitors are not efficiently implemented in the current Sun JDK. Since Java allows any object to be synchronizable (with or without any synchronized methods), using a lock structure for each object can be very costly in terms of memory. To minimize memory requirements, the Sun JDK keeps monitors outside of the objects. This requires the run-time system to first query each monitor in a monitor cache before itis used, which is quite inefficient. Further, the monitor cache itself needs to be locked during these queries to avoid race conditions. Thus, this monitor implementation approach is not scalable. CACAO, in contrast, is a system that implements monitors using a hash table indexed by the address of the associated object [Krall and Proebst 1998]. Because only a small number of objects that require mutually-exclusive access (called a mutexobject) are locked at any given time, this approach generally leads to decreased memory usage. Each of these objects maintains a count of how many lock operations have been performed on it without any corresponding unlock operations. When the count goes to zero, the lock is not owned by any thread. A mutex object, however, is not destroyed when its count reaches zero under the assumption that the mutex object will be reused again soon. The mutex object is destroyed only when a new mutex object collides with it in the hash table. This memory allocation approach has the advantage of requiring less code to implement lock and unlock operations. Since the hash table entries will be free only at the beginning of the program and will never be freed again, the code to lock the mutex need not check if the entry is free. The unlocking code also does not need to check whether the hash entry should be freed. Thethin locks approach in IBM’s JDK 1.1.2 for AIX improves thread synchronization by optimizing lock operations for the most common cases [Bacon et al. 1998].Thin locks, which require only a partial word per object, are used for objects that are not subject to any contention, do not have wait/notify operations performed on them, and are not locked to an excessive nesting depth. Objects that do not meet the criterion usefat locks, which are multiword locks similar to those used in the standard Java implementation. To minimize the memory required for each object’s lock, 24 bits in the object’s header are used for the lock structure. The other values stored in the header are compacted using various encoding schemes to make the 24 bits available for this lock structure. This 24-bit field stores either a thin lock directly, or a pointer to a fat lock. The dedicated lock for each object allows the lock/unlock operations on the thin locks to be performed using only a few machine instructions. This approach also eliminates the need to synchronize the monitor cache.

ผลลัพธ์ (ไทย) 1:

ประสานด้ายเป็นปัญหาประสิทธิภาพการทำงานที่อาจเกิดขึ้นในโปรแกรมจาวาจำนวนมากที่ใช้ multithreading ตั้งแต่ห้องสมุด java จะดำเนินการในลักษณะที่หัวข้อปลอดภัยประสิทธิภาพการทำงานของโปรแกรม singlethreaded แม้อาจลดลงเนื่องจากการทำข้อมูลให้ตรงกัน ใน java ประสานให้ผ่านจอภาพซึ่งเป็นโครงสร้างภาษาระดับที่ใช้ในการรับประกันการเข้าถึงร่วมกัน แต่เพียงผู้เดียวกับข้อมูลโครงสร้างที่ใช้ร่วมกัน [Silberschatz และ galvi​​n 1997] แต่น่าเสียดายที่การตรวจสอบไม่ได้ดำเนินการอย่างมีประสิทธิภาพใน jdk ดวงอาทิตย์ในปัจจุบัน ตั้งแต่ java ช่วยให้วัตถุใด ๆ ที่จะเป็น synchronizable (มีหรือไม่มีวิธีการทำข้อมูลให้ตรงกันใด ๆ ) โดยใช้โครงสร้างล็อคสำหรับแต่ละวัตถุจะมีค่าใช้จ่ายสูงมากในแง่ของหน่วยความจำเพื่อลดความต้องการหน่วยความจำ jdk ดวงอาทิตย์ช่วยให้การตรวจสอบภายนอกของวัตถุ นี้ต้องใช้ระบบเวลาทำงานไปก่อนแบบสอบถามแต่ละจอในแคชตรวจสอบก่อนที่จะ itis ใช้ซึ่งจะไม่มีประสิทธิภาพมาก เพิ่มเติมแคชจอตัวเองจะต้องมีการล็อคในระหว่างการค้นหาเหล​​่านี้เพื่อหลีกเลี่ยงสภาพการแข่งขัน จึงดำเนินการตรวจสอบวิธีการที่ไม่ได้ปรับขนาด โกโก้ในทางตรงกันข้ามเป็นระบบที่ดำเนินการตรวจสอบโดยใช้ตารางแฮชการสร้างดัชนีโดยที่อยู่ของวัตถุที่เกี่ยวข้อง [krall และ proebst 1998] เพราะเพียงจำนวนน้อยของวัตถุที่ต้องการเข้าถึงร่วมกัน แต่เพียงผู้เดียว (เรียกว่า mutexobject) จะถูกล็อคในเวลาใดก็ตามวิธีนี้มักนำไปสู่​​การลดลงการใช้งานหน่วยความจำแต่ละของวัตถุเหล่านี้ยังคงนับว่าการดำเนินงานหลายล็อคได้รับการดำเนินการเกี่ยวกับการดำเนินงานได้โดยไม่ต้องปลดล็อคใด ๆ ที่เกี่ยวข้อง เมื่อนับไปที่ศูนย์ล็อคไม่ได้เป็นเจ้าของกระทู้ใด ๆ วัตถุ mutex แต่ไม่ได้ทำลายเมื่อนับถึงศูนย์ของภายใต้สมมติฐานว่าวัตถุ mutex จะนำกลับมาใช้อีกครั้งในเร็ว ๆ นี้วัตถุ mutex ถูกทำลายเฉพาะเมื่อวัตถุ mutex ใหม่ชนกับมันในตารางแฮช นี้วิธีการจัดสรรหน่วยความจำได้ประโยชน์จากการที่ต้องใช้รหัสน้อยที่จะดำเนินการล็อคและปลดล็อคการดำเนินงาน ตั้งแต่รายการตารางแฮชจะเป็นอิสระเพียงจุดเริ่มต้นของโปรแกรมและจะไม่ถูกปล่อยให้เป็นอิสระอีกครั้งรหัสเพื่อล็อค mutex ไม่จำเป็นต้องตรวจสอบว่ารายการที่เป็นอิสระรหัสปลดล็อคยังไม่จำเป็นต้องตรวจสอบว่ารายการกัญชาควรจะปล่อยให้เป็นอิสระ thethin ล็อควิธีการใน ibm ของ jdk 1.1.2 การปรับปรุง Aix ประสานด้ายโดยการเพิ่มประสิทธิภาพการดำเนินงานล็อคสำหรับกรณีที่พบบ่อยที่สุด [เบคอนและอัล 1998]. ล็อคบางซึ่งต้องการเพียงคำบางส่วนต่อวัตถุที่ใช้สำหรับวัตถุที่ไม่อยู่ภายใต้การต่อสู้ใด ๆจะได้ไม่ต้องรอ / แจ้งการดำเนินงานที่ดำเนินการเกี่ยวกับพวกเขาและไม่ได้ล็อคเพื่อความลึกการทำรังมากเกินไป วัตถุที่ไม่เป็นไปตามเกณฑ์ล็อค usefat ซึ่งเป็นล็อค multiword คล้ายกับที่ใช้ในการดำเนินงานจาวามาตรฐาน เพื่อลดหน่วยความจำที่จำเป็นสำหรับการล็อคของแต่ละวัตถุ 24 บิตในส่วนหัวของวัตถุที่ใช้สำหรับโครงสร้างล็อคค่าอื่น ๆ ที่เก็บไว้ในส่วนหัวของการบดอัดโดยใช้การเข้ารหัสแบบต่างๆเพื่อให้ 24 บิตสำหรับโครงสร้างล็อคนี้ 24 บิตนี้ร้านค้าสนามทั้งล็อคบางโดยตรงหรือชี้ไปยังล็อคไขมัน ล็อคเฉพาะสำหรับแต่ละวัตถุช่วยให้ล็อค / ปลดล็อคการดำเนินงานในบางที่จะดำเนินการโดยใช้คำแนะนำเครื่องเพียงไม่กี่วิธีนี้ยังช่วยลดความจำเป็นในการประสานการตรวจสอบแคช

ผลลัพธ์ (ไทย) 2:

ตรงหัวข้อคือ ปัญหาประสิทธิภาพการทำงานอาจเกิดขึ้นในจาวาโปรแกรมมัลติเธรดที่ใช้ เนื่องจากจาวาไลบรารีจะดำเนินการในลักษณะเธรดปลอดภัย ประสิทธิภาพการทำงานของโปรแกรมประยุกต์ singlethreaded แม้อาจเสื่อมโทรมเนื่องจากการซิงโครไนส์ ใน Java ให้ตรงผ่านจอภาพ ซึ่งเป็นโครงสร้างระดับภาษาที่ใช้ในการค้ำประกันร่วมกันผูกขาดเข้าถึงใช้ร่วมกันข้อมูลโครง [Silberschatz และ Galvin 1997] ไม่อับ จอจะได้มีประสิทธิภาพใช้ใน JDK ดวงอาทิตย์ปัจจุบัน เนื่องจาก Java ช่วยให้วัตถุที่จะ synchronizable (มี หรือไม่ มีวิธีใด ๆ ให้ตรงกัน), ใช้โครงสร้างการล็อกสำหรับแต่ละวัตถุได้ค่าใช้จ่ายสูงมากในแง่ของหน่วยความจำ เพื่อลดความต้องการหน่วยความจำ JDK ดวงอาทิตย์ช่วยให้จอภาพภายนอกของวัตถุ ต้องการให้ระบบรันไทม์ก่อน สอบถามแต่ละจอภาพในจอภาพก่อนที่จะใช้ ซึ่งจะค่อนข้างต่ำ เพิ่มเติม แคชของการตรวจสอบตัวเองต้องการจะล็อคในระหว่างการสอบถามเหล่านี้เพื่อหลีกเลี่ยงเงื่อนไขการแข่งขัน ดังนั้น วิธีการใช้งานจอภาพนี้ไม่สามารถปรับ CACAO คมชัด เป็นระบบที่ตรวจสอบโดยใช้ตารางแฮชดัชนี โดยอยู่ของวัตถุเกี่ยวข้อง [Krall และ Proebst ปี 1998] เพราะเพียงจำนวนน้อยของวัตถุที่ต้องการการเข้าร่วมกันผูกขาด (เรียกว่าเป็น mutexobject) จะถูกล็อคในเวลาที่กำหนด วิธีนี้โดยทั่วไปนำไปใช้หน่วยความจำลดลง ของวัตถุเหล่านี้เก็บรักษาจำนวนจำนวนล็อคมีการดำเนินการไม่สอดคล้องใด ๆ ปลดล็อกการดำเนินงาน เมื่อนับไปศูนย์ ล็อคไม่เป็นหัวข้อใด ๆ วัตถุมี mutex อย่างไรก็ตาม คือไม่ทำลายเมื่อจำนวนของศูนย์ภายใต้สมมติฐานที่ว่า จะมีนำวัตถุ mutex อีกครั้งเร็ว ๆ นี้ วัตถุ mutex ถูกทำลายเมื่อวัตถุ mutex ใหม่ collides กับในตารางแฮช วิธีการปันส่วนหน่วยความจำนี้มีข้อดีของต้องน้อยกว่ารหัสที่ใช้ล็อค และปลดล็อคการดำเนินงาน เนื่องจากรายการในตารางแฮจะฟรีเฉพาะที่จุดเริ่มต้นของโปรแกรม และจะไม่มีรอดอีก รหัสล็อก mutex ต้องไม่ตรวจถ้ารายการไม่ รหัสปลดล็อกยังไม่จำเป็นต้องตรวจสอบว่า รายการแฮจะรอด วิธีล็อค Thethin ใน JDK ของ IBM 1.1.2 สำหรับอิ๊กซ์ซองเพิ่มตรงหัวข้อ โดยเพิ่มประสิทธิภาพการดำเนินการล็อกสำหรับกรณีทั่วไป [เบคอนและ al. ปี 1998]ใช้สำหรับวัตถุที่ไม่ มีการช่วงชิงงานบน ล็อคบาง ซึ่งต้องการเพียงคำบางส่วนต่อวัตถุ ไม่มีรอ/แจ้งให้ดำเนินการพวกเขา และไม่ได้ถูกล็อกเพื่อความลึกซ้อนมากเกินไป วัตถุที่ไม่ตรงกับเกณฑ์ usefat ล็อค ซึ่งคล้ายกับที่ใช้ในการดำเนินการจาวามาตรฐาน multiword ล็อค เพื่อลดหน่วยความจำที่จำเป็นสำหรับแต่ละวัตถุล็อค 24 บิตในหัวข้อของวัตถุจะใช้โครงสร้างล็อก ค่าอื่น ๆ เก็บไว้ในหัวข้อที่กระชับใช้แผนงานการเข้ารหัสต่าง ๆ เพื่อพร้อมใช้งานสำหรับโครงสร้างนี้ล็อค 24 บิต ฟิลด์นี้ 24 บิตเก็บล็อคบางโดยตรง หรือชี้ล็อคไขมัน ล็อคเฉพาะสำหรับแต่ละวัตถุช่วยให้การดำเนินงานล็อค/ปลดล็อคในล็อคบางควรใช้เพียงไม่กี่เครื่องคำ วิธีการนี้ยังกำจัดต้องการซิงโครไนส์แคจอภาพ

ผลลัพธ์ (ไทย) 3:

การซิงโครไนซ์ชุดคำสั่งหรือเธรดมีปัญหา ประสิทธิภาพ การทำงานในโปรแกรม Java จำนวนมากที่ใช้งานมัลติเธรดดิ้ง เนื่องจากไลบรารีจาวามีลักษณะการทำงานในลักษณะเกลียว - ตู้นิร ภัย ที่ ประสิทธิภาพ การทำงานของแอปพลิเคชัน singlethreaded อาจจะถูกปรับระดับลงเนื่องจากการซิงโครไนซ์ การซิงโครไนซ์ในเกาะชวามีให้ผ่านทางจอมอนิเตอร์ซึ่งจะสร้าง ภาษา ที่ใช้ในการรับประกันการเข้าถึงร่วมกัน - เฉพาะสำหรับข้อมูลที่ใช้งานร่วมกัน - โครงสร้าง[ silberschatz และ galvin 1997 ] น่าเสียดายที่จอมอนิเตอร์ไม่ได้นำไปใช้ในแสงอาทิตย์ jdk. ในปัจจุบันได้อย่างมี ประสิทธิภาพ นับตั้งแต่ Java ช่วยให้วัตถุใดๆได้ synchronizable (พร้อมด้วยหรือไม่มีวิธีการใดวิธีการหนึ่งซิงโครไนซ์ใดๆ)โดยใช้โครงสร้างระบบล็อคสำหรับวัตถุแต่ละตัวสามารถมีราคาแพงเป็นอย่างมากในด้านของหน่วยความจำเพื่อลดความต้องการหน่วยความจำสำหรับอาบแดด jdk ที่ช่วยให้จอมอนิเตอร์ ภายนอก ของวัตถุที่ โรงแรมแห่งนี้ต้องใช้ระบบเวลาเรียกใช้งานเป็นครั้งแรกการสืบค้นแต่ละจอมอนิเตอร์จอมอนิเตอร์ที่อยู่ในแคช itis ก่อนใช้งานซึ่งจะมี ประสิทธิภาพ มาก เพิ่มเติมแคชจอมอนิเตอร์เองจะต้องถูกล็อคอยู่ในระหว่างการค้นหาข้อมูลเหล่านี้เพื่อหลีกเลี่ยงเงื่อนไขการแข่งขัน ดังนั้นแนวทางการนำไปใช้งานจอมอนิเตอร์นี้ไม่สามารถปรับขนาดได้อย่างยืดหยุ่น ต้นโกโก้ในความเปรียบต่างเป็นระบบที่ได้รับการรับรองว่าการดำเนินการตรวจสอบการใช้ตารางแฮชแอดเดรสที่จัดทำดัชนีโดยที่ของวัตถุที่เกี่ยวข้อง[ krall และ proebst 1998 ] เพราะเพียงหมายเลขขนาดเล็กของสิ่งของที่จำเป็นต้องใช้การเชื่อมต่อร่วมกัน - แบบเฉพาะตัว(เรียกว่า mutexobject )จะถูกล็อคในเวลาที่กำหนดซึ่งวิธีการนี้โดยทั่วไปแล้วนำไปสู่การใช้งานหน่วยความจำที่ลดลงแต่ละวัตถุเหล่านี้ยังคงรักษาจำนวนของการล็อคการดำเนินงานจำนวนมากมีการดำเนินการที่ไม่มีการทำงานใดๆที่เกี่ยวข้องปลดล็อค เมื่อนับไปยังศูนย์ล็อคที่ไม่ได้เป็นเจ้าของโดยลวดลายใดๆ ออบเจกต์ Fast mutex แต่ถึงอย่างไรก็ตามจะไม่ถูกทำลายเมื่อมาถึงจำนวนของศูนย์ ภายใต้ สมมุติฐานที่ว่าวัตถุ Fast mutex จะหรือนำกลับมาใช้ใหม่ได้อีกครั้งในเร็วๆนี้Fast mutex วัตถุที่ถูกทำลายเท่านั้นเมื่อมีวัตถุ Fast mutex ใหม่ชนกับมันในตาราง Hash แนวทางการจัดสรรหน่วยความจำแห่งนี้ได้รับประโยชน์จากต้องใช้รหัสไม่น้อยในการนำตัวล็อคและปลดล็อคการทำงาน นับตั้งแต่รายการโต๊ะ Hash จะเป็นแบบไม่เสียค่าบริการเพียงอยู่ในขั้นเริ่มต้นของโปรแกรมและจะไม่ได้รับกลับคืนมาอีกครั้งโค้ดเพื่อล็อค Fast mutex ที่ไม่จำเป็นต้องตรวจสอบว่ารายการที่เป็นแบบไม่เสียค่าบริการรหัสปลดล็อคที่ยังไม่จำเป็นต้องตรวจสอบว่ารายการ Hash จะต้องปลดปล่อย thethin ล็อคเข้าใน jdk ของ IBM 1.1.2 สำหรับ Aix ช่วยปรับปรุงการซิงโครไนซ์ชุดคำสั่งหรือเธรดโดยการดำเนินงานล็อคการปรับแต่งสำหรับในกรณีที่ใช้โดยทั่วไปส่วนใหญ่[เบคอน et al . 1998 ].ล็อคบางที่ต้องมีเพียงคำต่อวัตถุบางส่วนมีการใช้สำหรับวัตถุที่ไม่ได้ขึ้นอยู่กับประเด็นใดๆไม่มีรอ/แจ้งให้การทำงานทำให้พวกเขาและไม่ได้ถูกล็อคสำหรับความลึกทำรังของนกมากเกินไป วัตถุที่ไม่ตรงตามเกณฑ์ที่ล็อค usefat ซึ่งมีล็อค multiword เหมือนกับที่ใช้ในการนำไปใช้งาน Java มาตรฐาน ในการลดหน่วยความจำที่จำเป็นสำหรับล็อคของวัตถุแต่ละตัว 24 บิตในส่วนหัวของวัตถุที่ใช้สำหรับโครงสร้างล็อคค่าอื่นๆที่จัดเก็บอยู่ในหัวต่อที่อเมริกาใต้ใช้แผนร่างการทำงาน( Schemes )การเข้ารหัสต่างๆในการทำให้ 24 บิตที่มีอยู่สำหรับโครงสร้างล็อคนี้ ฟิลด์ 24 - บิตนี้จะจัดเก็บการล็อคบางโดยตรงหรือตัวชี้เพื่อล็อคอ้วน ล็อคที่มีให้สำหรับวัตถุแต่ละรุ่นช่วยให้ล็อค/ปลดล็อคการทำงานในระบบล็อคบางที่จะทำโดยใช้เพียงคำแนะนำเพียงไม่กี่เครื่องวิธีนี้ยังช่วยขจัดความจำเป็นในการซิงโครไนซ์แคชจอมอนิเตอร์