Threads เป็นแนวคิดที่สำคัญมากในการเขียนโปรแกรม Java บทความนี้จะอธิบายโดยละเอียดในรูปแบบของตัวอย่าง การวิเคราะห์เฉพาะมีดังนี้:
ก่อนอื่นเลย การใช้การล็อคเกลียวคืออะไร? ตัวอย่างเช่น หากคุณมีเงินในธนาคารอยู่ 30,000 หยวน และคุณไปที่ธนาคารเพื่อถอนเงิน หลังจากที่คุณป้อนรหัสผ่าน คุณได้ป้อนจำนวนเงินที่ถอนแล้ว ตัวอย่างเช่น หากคุณป้อน 20,000 ก็เป็นเช่นนั้น หมายความว่าธนาคารจะไปเอาเงินให้คุณ ตอนนั้นภรรยาคุณไปถอนเงินที่ธนาคารด้วยและคุณ ภรรยาของผมถอนเงิน 20,000 ออกไปด้วย เพราะบัญชีของคุณยังคงมีอยู่ 30,000 ในเวลานี้ ธนาคารจึงดำเนินการแบบเดียวกันในส่วนของภรรยาคุณ ด้วยวิธีนี้ หลังจากที่คุณสองคนดำเนินการตามลำดับเสร็จแล้ว ธนาคารก็ควรจะมีเงิน 30,000 บันทึกไว้ในบัญชีของคุณ เงินฝาก 10,000 หยวน ดีขนาดนี้เลยเหรอ? เพื่อแก้ปัญหานี้จึงนำความรู้เรื่องการล็อคเกลียวมาใช้
1. ตัวอย่างของการซิงโครไนซ์เธรดที่ไม่มีการจัดการ:
คลาสสาธารณะ TextSync ใช้งาน Runnable{ /**การซิงโครไนซ์เธรดที่ไม่ได้จัดการ* @param args */ เวลา เวลา = เวลาใหม่(); โมฆะสาธารณะคงที่ main(String[] args) { TextSync text = new TextSync(); (ข้อความ); เธรด t2 = เธรดใหม่ (ข้อความ); t1.setName("t1"); t2.setName("t2"); t2.start(); } @Override โมฆะสาธารณะ () { time.add(Thread.currentThread().getName()); }} เวลาคลาส { ส่วนตัวคงที่ int num = 0; ลอง { num++; //เมื่อเธรดแรกดำเนินการจนถึงจุดนี้ num จะกลายเป็น 1 และเธรดแรกจะหยุดชั่วคราวเป็นเวลาหนึ่งวินาที และเธรดที่สองหยุดชั่วคราวหนึ่งวินาที // จำนวนของเธรดแรกกลายเป็น 2 ในเวลานี้ ดังนั้นผลลัพธ์สุดท้ายคือ 2; Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace() } System.out.println (name+ " คือ "+num+" เธรดการดำเนินการครั้งที่ 2");ผลลัพธ์ที่ได้:
t2 เป็นเธรดที่สองของการดำเนินการ t1 เป็นเธรดที่สองของการดำเนินการ
2. การซิงโครไนซ์เธรด
คลาสสาธารณะ TextSynctwo ใช้งาน Runnable{ /**การซิงโครไนซ์เธรด* @param args */ Time1 time = new Time1(); public static void main(String[] args) { TextSynctwo text = new TextSynctwo(); ข้อความ); เธรด t2 = เธรดใหม่ (ข้อความ); t1.setName("t1"); t2.setName("t2"); t1.start(); t2.start(); } @Override สาธารณะ void run() { time.add(Thread.currentThread().getName()); }}class Time1 { ส่วนตัวคงที่ int num = 0; ซิงโครไนซ์ล็อคเธรดปัจจุบันซึ่งสามารถประกาศได้เมื่อมีการกำหนดวิธีการหรือตั้งค่าในวิธีการ การเพิ่มโมฆะการซิงโครไนซ์สาธารณะ (ชื่อสตริง) {// ซิงโครไนซ์ (สิ่งนี้) {// ล็อคเธรดปัจจุบันเพื่อป้องกันไม่ให้เธรดอื่นดำเนินการลอง { num ++; Thread.sleep (1000); } catch (InterruptedException e) { e . printStackTrace(); } System.out.println(name+"is the "+num+"th thread of Execution.");ผลลัพธ์ที่ได้:
t1 เป็นเธรดแรกของการดำเนินการ t2 เป็นเธรดที่สองของการดำเนินการ
3. การหยุดชะงัก
คลาสสาธารณะ TestDeadLock ใช้งาน Runnable{ /**Deadlock* @param args */ private int flag = 0; static Object o1 = new Object(); { TestDeadLock td1 = TestDeadLock ใหม่ (); TestDeadLock td2 = TestDeadLock ใหม่ (); = 1; td2.flag = 2; เธรด t1 = เธรดใหม่ (td1); ; t2.start(); } @ แทนที่การรันโมฆะสาธารณะ () { System.out.println(Thread.currentThread().getName()); if(flag == 1){ synchronized(o1){ ลอง { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace( } ซิงโครไนซ์ (o2) { System.out.println ("1"); } } } ถ้า (ตั้งค่าสถานะ == 2) { synchronized(o2){ ลอง { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } ซิงโครไนซ์(o1){ System.out.println("2");4. ล็อค
คลาสสาธารณะ TT ใช้ Runnable{ /**Lock* @param args */ int b = 100; public static void main(String[] args) { TT tt = new TT(); Thread th = new Thread(tt.); .start(); ลอง { tt.m2( } catch (ข้อยกเว้น e) { e.printStackTrace( } System.out.println(tt.b); } @Override public void run() { ลอง { m1(); } catch (ข้อยกเว้น e) { e.printStackTrace(); } } โมฆะที่ซิงโครไนซ์ส่วนตัว b = 1,000; Thread.sleep(5000); System.out.println("b="+b); } โมฆะการซิงโครไนซ์ส่วนตัว ข้อยกเว้น { Thread.sleep (2500); b = 2500;ผลลัพธ์ตอนนี้คือ:
1,000b=1,000
จะเห็นได้ว่า m2 จะถูกดำเนินการก่อน และ m1 จะไม่สามารถดำเนินการได้จนกว่า m2 จะเสร็จสมบูรณ์
ฉันหวังว่าบทความนี้จะเป็นประโยชน์กับการออกแบบการเขียนโปรแกรม Java ของทุกคน