java多線程基本使用_ZenDei技術網路在線

一．概念 1.進程 1.1進程：是一個正在進行中的程式，每一個進程執行都有一個執行順序，該順序是一個執行路徑，或者叫一個控制單元。 1.2線程：就是進程中一個獨立的控制單元，線程在控制著進程的執行，一個進程中至少有一個線程。 1.3舉例java VM： Java VM啟動的時候會有一個進程java. ...

一．概念

1.進程

1.1進程：是一個正在進行中的程式，每一個進程執行都有一個執行順序，該順序是一個執行路徑，或者叫一個控制單元。

1.2線程：就是進程中一個獨立的控制單元，線程在控制著進程的執行，一個進程中至少有一個線程。

1.3舉例java VM：

Java VM啟動的時候會有一個進程java.exe,該進程中至少有一個線程在負責java程式的運行，而且這個線程運行的代碼存在於main方法中，該線程稱之為主線程。擴展：其實更細節說明jvm,jvm啟動不止一個線程，還有負責垃圾回收機制的線程

2.多線程存在的意義：提高執行效率

二.多線程的創建

1.多線程創建的第一種方式，繼承Thread類

1.1定義類繼承Thread，覆寫Thread類中的run方法是為了將自定義的代碼存儲到run方法中，讓線程運行

1.2調用線程的start方法，該方法有兩個作用：啟動線程，調用run方法

1.3多線程運行的時候，運行結果每一次都不同，因為多個線程都獲取cpu的執行權，cpu執行到誰，誰就運行，明確一點，在某一個時刻，只能有一個程式在運行。（多核除外），cpu在做著快速的切換，以到達看上去是同時運行的效果。我們可以形象把多線程的運行行為在互搶cpu的執行權。這就是多線程的一個特性，隨機性。誰搶到，誰執行，至於執行多久，cpu說了算。

 1 public class Demo extends Thread{
 2     public void run(){
 3         for (int x = 0; x < 60; x++) {
 4             System.out.println(this.getName()+"demo run---"+x);
 5         }
 6     }
 7     
 8     public static void main(String[] args) {
 9         Demo d=new Demo();//創建一個線程
10         d.start();//開啟線程，並執行該線程的run方法
11         d.run(); //僅僅是對象調用方法，而線程創建了但並沒有運行
12         for (int x = 0; x < 60; x++) {
13             System.out.println("Hello World---"+x);
14         }
15     }
16 
17 }

View Code

2 創建多線程的第二種方式，步驟：

2.1定義類實現Runnable介面

2.2覆蓋Runnable介面中的run方法：將線程要運行的代碼存放到run方法中

2.3.通過Thread類建立線程對象

2.4.將Runnable介面的子類對象作為實際參數傳遞給Thread類的構造函數

為什麼要將Runnable介面的子類對象傳遞給Thread的構造函數：因為自定義的run方法所屬的對象是Runnable介面的子類對象，所以要讓線程去執行指定對象的run方法，就必須明確該run方法的所屬對象

2.5.調用Thread類的start方法開啟線程並調用Runnable介面子類的方法

 1 /*
 2  * 需求:簡易買票程式,多個視窗同時賣票
 3  */
 4 public class Ticket implements Runnable {
 5     private static int tick = 100;
 6     Object obj = new Object();
 7     boolean flag=true;
 8 
 9     public void run() {
10         if(flag){
11             while (true) {
12                 synchronized (Ticket.class) {
13                     if (tick > 0) {
14                         System.out.println(Thread.currentThread().getName()
15                                 + "code:" + tick--);
16                     }
17                 }
18             }
19         }else{
20             while(true){
21                 show();
22             }
23         }
24         
25     }
26 
27     public static synchronized void show() {
28         if (tick > 0) {
29             System.out.println(Thread.currentThread().getName() + "show:"
30                     + tick--);
31         }
32     }
33 
34 }
35 
36 class ThisLockDemo {
37     public static void main(String[] args) {
38         Ticket t = new Ticket();
39 
40         Thread t1 = new Thread(t);
41         try {
42             Thread.sleep(10);
43         } catch (Exception e) {
44             // TODO: handle exception
45         }
46         t.flag=false;
47         Thread t2 = new Thread(t);
48         //Thread t3 = new Thread(t);
49         //Thread t4 = new Thread(t);
50 
51         t1.start();
52         t2.start();
53         //t3.start();
54         //t4.start();
55     }
56 }

View Code

3.實現方式和繼承方式有什麼區別

3.1.實現方式避免了單繼承的局限性，在定義線程時建議使用實現方式

3.2.繼承Thread類：線程代碼存放在Thread子類run方法中

3.3.實現Runnable:線程代碼存放在介面的子類run方法中

4.多線程-run和start的特點

4.1為什麼要覆蓋run方法呢:

Thread類用於描述線程，該類定義了一個功能，用於存儲線程要運行的代碼，該存儲功能就是run方法，也就是說該Thread類中的run方法，用於存儲線程要運行的代碼

5.多線程運行狀態

創建線程-運行---sleep()/wait()--凍結---notify()---喚醒

創建線程-運行---stop()—消亡

創建線程-運行---沒搶到cpu執行權—臨時凍結

6.獲取線程對象及其名稱

6.1.線程都有自己預設的名稱，編號從0開始

6.2.static Thread currentThread():獲取當前線程對象

6.3.getName():獲取線程名稱

6.4.設置線程名稱:setName()或者使用構造函數

 1 public class Test extends Thread{
 2     
 3     Test(String name){
 4         super(name);
 5     }
 6     
 7     public void run(){
 8         for (int x = 0; x < 60; x++) {
 9             System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
10         }
11     }
12 }
13 
14 class ThreadTest{
15     public static void main(String[] args) {
16         Test t1=new Test("one---");
17         Test t2=new Test("two+++");
18         t1.start();
19         t2.start();
20         t1.run();
21         t2.run();
22         for (int x = 0; x < 60; x++) {
23             System.out.println("main----"+x);
24         }
25     }
26 }

View Code

三.多線程的安全問題

1.多線程出現安全問題的原因：

1.1.當多條語句在操作同一個線程共用數據時，一個線程對多條語句只執行了一部分，還沒有執行完，另一個線程參與進來執行，導致共用數據的錯誤

1.2.解決辦法：對多條操作共用數據的語句，只能讓一個線程都執行完，在執行過程中，其他線程不可以參與執行

1.3.java對於多線程的安全問題提供了專業的解決方式，就是同步代碼塊：

Synchronized(對象){需要被同步的代碼}，對象如同鎖，持有鎖的線程可以在同步中執行，沒有持有鎖的線程即使獲取cpu執行權，也進不去，因為沒有獲取鎖

2.同步的前提：

2.1.必須要有2個或者2個以上線程

2.2.必須是多個線程使用同一個鎖

2.3.好處是解決了多線程的安全問題

2.4.弊端是多個線程需要判斷鎖，較消耗資源

5.同步函數

定義同步函數,在方法錢用synchronized修飾即可

 1 /*
 2  * 需求:
 3  * 銀行有一個金庫，有兩個儲戶分別存300元,每次存100元,存3次
 4  * 目的:該程式是否有安全問題,如果有,如何解決
 5  * 如何找問題:
 6  * 1.明確哪些代碼是多線程代碼
 7  * 2.明確共用數據
 8  * 3.明確多線程代碼中哪些語句是操作共用數據的
 9  */
10 
11 public class Bank {
12 
13     private int sum;
14 
15     Object obj = new Object();
16 
17     //定義同步函數,在方法錢用synchronized修飾即可
18     public synchronized void add(int n) {
19         //synchronized (obj) {
20             sum = sum + n;
21             try {
22                 Thread.sleep(10);
23             } catch (InterruptedException e) {
24                 // TODO Auto-generated catch block
25                 e.printStackTrace();
26             }
27             System.out.println("sum=" + sum);
28         //}
29 
30     }
31 
32 }
33 
34 class Cus implements Runnable {
35     private Bank b = new Bank();
36 
37     public void run() {
38         for (int x = 0; x < 3; x++) {
39             b.add(100);
40         }
41     }
42 }
43 
44 class BankDemo {
45     public static void main(String[] args) {
46         Cus c = new Cus();
47         Thread t1 = new Thread(c);
48         Thread t2 = new Thread(c);
49 
50         t1.start();
51         t2.start();
52     }
53 }

View Code

6.同步的鎖

6.1函數需要被對象調用，那麼函數都有一個所屬對象引用，就是this.,所以同步函數使用的鎖是this

6.2.靜態函數的鎖是class對象

靜態進記憶體時，記憶體中沒有本類對象，但是一定有該類對應的位元組碼文件對象，類名.class,該對象的類型是Class

6.3.靜態的同步方法，使用的鎖是該方法所在類的位元組碼文件對象，類名.class

 1 /*
 2  * 需求:簡易買票程式,多個視窗同時賣票
 3  */
 4 public class Ticket implements Runnable {
 5     private static int tick = 100;
 6     Object obj = new Object();
 7     boolean flag=true;
 8 
 9     public void run() {
10         if(flag){
11             while (true) {
12                 synchronized (Ticket.class) {
13                     if (tick > 0) {
14                         System.out.println(Thread.currentThread().getName()
15                                 + "code:" + tick--);
16                     }
17                 }
18             }
19         }else{
20             while(true){
21                 show();
22             }
23         }
24         
25     }
26 
27     public static synchronized void show() {
28         if (tick > 0) {
29             System.out.println(Thread.currentThread().getName() + "show:"
30                     + tick--);
31         }
32     }
33 
34 }
35 
36 class ThisLockDemo {
37     public static void main(String[] args) {
38         Ticket t = new Ticket();
39 
40         Thread t1 = new Thread(t);
41         try {
42             Thread.sleep(10);
43         } catch (Exception e) {
44             // TODO: handle exception
45         }
46         t.flag=false;
47         Thread t2 = new Thread(t);
48         //Thread t3 = new Thread(t);
49         //Thread t4 = new Thread(t);
50 
51         t1.start();
52         t2.start();
53         //t3.start();
54         //t4.start();
55     }
56 }

View Code

7.多線程，單例模式-懶漢式

懶漢式與餓漢式的區別：懶漢式能延遲實例的載入，如果多線程訪問時，懶漢式會出現安全問題，可以使用同步來解決，用同步函數和同步代碼都可以，但是比較低效，用雙重判斷的形式能解決低效的問題，加同步的時候使用的鎖是該類鎖屬的位元組碼文件對象

 1 /*
 2  * 單例模式
 3  */
 4 //餓漢式
 5 public class Single {
 6     private static final Single s=new Single();
 7     private Single(){}
 8     public static Single getInstance(){
 9         return s;
10     }
11 
12 }
13 
14 //懶漢式
15 class Single2{
16     private static Single2 s2=null;
17     private Single2(){}
18     public static Single2 getInstance(){
19         if(s2==null){
20             synchronized(Single2.class){
21                 if(s2==null){
22                     s2=new Single2();    
23                 }
24             }
25         }
26         return s2;
27     }
28 }
29 
30 class SingleDemo{
31     public static void main(String[] args) {
32         System.out.println("Hello World");
33     }
34 }

View Code

8.多線程-死鎖

同步中嵌套同步會出現死鎖

 1 /*
 2  * 需求:簡易買票程式,多個視窗同時賣票
 3  */
 4 public class DeadTest implements Runnable {
 5     private boolean flag;
 6 
 7     DeadTest(boolean flag) {
 8         this.flag = flag;
 9     }
10 
11     public void run() {
12         if (flag) {
13             synchronized(MyLock.locka){
14                 System.out.println("if locka");
15                 synchronized(MyLock.lockb){
16                     System.out.println("if lockb");
17                 }
18             }
19         } else {
20             synchronized(MyLock.lockb){
21                 System.out.println("else lockb");
22                 synchronized(MyLock.locka){
23                     System.out.println("else locka");
24                 }
25             }
26         }
27     }
28 }
29 
30 class MyLock{
31     static Object locka=new Object();
32     static Object lockb=new Object();
33 }
34 
35 class DeadLockDemo {
36     public static void main(String[] args) {
37         Thread t1 = new Thread(new DeadTest(true));
38         Thread t2 = new Thread(new DeadTest(false));
39 
40         t1.start();
41         t2.start();
42     }
43 }

View Code

----------技術改變生活，知識改變命運!