2. 程式人生 > >Java學習多執行緒第一天

Java學習多執行緒第一天

阿新 • • 發佈：2019-08-08

內容介紹

  • Thread
  • 執行緒建立
  • 執行緒池
  • 執行緒狀態圖

1 多執行緒

1.1     多執行緒介紹

學習多執行緒之前，我們先要了解幾個關於多執行緒有關的概念。

程序：程序指正在執行的程式。確切的來說，當一個程式進入記憶體執行，即變成一個程序，程序是處於執行過程中的程式，並且具有一定獨立功能。

 

執行緒：執行緒是程序中的一個執行單元，負責當前程序中程式的執行，一個程序中至少有一個執行緒。一個程序中是可以有多個執行緒的，這個應用程式也可以稱之為多執行緒程式。

簡而言之：一個程式執行後至少有一個程序，一個程序中可以包含多個執行緒

 

 什麼是多執行緒呢？即就是一個程式中有多個執行緒在同時執行。

通過下圖來區別單執行緒程式與多執行緒程式的不同：

  •  單執行緒程式：即，若有多個任務只能依次執行。當上一個任務執行結束後，下一個任務開始執行。如，去網咖上網，網咖只能讓一個人上網，當這個人下機後，下一個人才能上網。
  •  多執行緒程式：即，若有多個任務可以同時執行。如，去網咖上網，網咖能夠讓多個人同時上網。

 

1.2     程式執行原理

  •   分時排程

所有執行緒輪流使用 CPU 的使用權，平均分配每個執行緒佔用 CPU 的時間。

  •  搶佔式排程

優先讓優先順序高的執行緒使用 CPU，如果執行緒的優先順序相同，那麼會隨機選擇一個(執行緒隨機性)，Java使用的為搶佔式排程。

1.2.1    搶佔式排程詳解

大部分作業系統都支援多程序併發執行，現在的作業系統幾乎都支援同時執行多個程式。比如：現在我們上課一邊使用編輯器，一邊使用錄屏軟體，同時還開著畫圖板，dos視窗等軟體。此時，這些程式是在同時執行，”感覺這些軟體好像在同一時刻執行著“。

 

實際上，CPU(中央處理器)使用搶佔式排程模式在多個執行緒間進行著高速的切換。對於CPU的一個核而言，某個時刻，只能執行一個執行緒，而 CPU的在多個執行緒間切換速度相對我們的感覺要快，看上去就是在同一時刻執行。

其實，多執行緒程式並不能提高程式的執行速度，但能夠提高程式執行效率，讓CPU的使用率更高。

1.3     主執行緒

回想我們以前學習中寫過的程式碼，當我們在dos命令列中輸入java空格類名回車後，啟動JVM，並且載入對應的class檔案。虛擬機器並會從main方法開始執行我們的程式程式碼，一直把main方法的程式碼執行結束。如果在執行過程遇到迴圈時間比較長的程式碼，那麼在迴圈之後的其他程式碼是不會被馬上執行的。如下程式碼演示：

class Demo{
    String name;
    Demo(String name){
        this.name = name;
    }
    void show()    {
        for (int i=1;i<=10000 ;i++ )        {
            System.out.println("name="+name+",i="+i);
        }
    }
}

class ThreadDemo {
    public static void main(String[] args)     {
        Demo d = new Demo("小強");
         Demo d2 = new Demo("旺財");
        d.show();        
        d2.show();
        System.out.println("Hello World!");
    }
}
View Code

若在上述程式碼中show方法中的迴圈執行次數很多，這時在d.show();下面的程式碼是不會馬上執行的，並且在dos視窗會看到不停的輸出name=小強,i=值，這樣的語句。為什麼會這樣呢？

原因是：jvm啟動後，必然有一個執行路徑(執行緒)從main方法開始的，一直執行到main方法結束，這個執行緒在java中稱之為主執行緒。當程式的主執行緒執行時，如果遇到了迴圈而導致程式在指定位置停留時間過長，則無法馬上執行下面的程式，需要等待迴圈結束後能夠執行。

那麼，能否實現一個主執行緒負責執行其中一個迴圈，再由另一個執行緒負責其他程式碼的執行，最終實現多部分程式碼同時執行的效果？

能夠實現同時執行，通過Java中的多執行緒技術來解決該問題。

1.4     Thread類

該如何建立執行緒呢？通過API中搜索，查到Thread類。通過閱讀Thread類中的描述。Thread是程式中的執行執行緒。Java 虛擬機器允許應用程式併發地執行多個執行執行緒。

 通過檢視API可以發現建立新執行執行緒有兩種方法。

  •  一種方法是將類宣告為 Thread 的子類。該子類應重寫 Thread 類的 run 方法。建立物件，開啟執行緒。run方法相當於其他執行緒的main方法。
  •  另一種方法是宣告一個實現 Runnable 介面的類。該類然後實現 run 方法。然後建立Runnable的子類物件，傳入到某個執行緒的構造方法中，開啟執行緒。

1.5     建立執行緒方式一繼承Thread類

建立執行緒的步驟：

　　1 定義一個類繼承Thread。

　　2 重寫run方法。

　　3 建立子類物件，就是建立執行緒物件。

　　4 呼叫start方法，開啟執行緒並讓執行緒執行，同時還會告訴jvm去呼叫run方法。

  測試類

public class Demo01 {
    public static void main(String[] args) {
        //建立自定義執行緒物件
        MyThread mt = new MyThread("新的執行緒！");
        //開啟新執行緒
        mt.start();
        //在主方法中執行for迴圈
        for (int i = 0; i < 10; i++) {
            System.out.println("main執行緒！"+i);
        }
    }
}

  自定義執行緒類

public class MyThread extends Thread {
    //定義指定執行緒名稱的構造方法
    public MyThread(String name) {
        //呼叫父類的String引數的構造方法，指定執行緒的名稱
        super(name);
    }
    /**
     * 重寫run方法，完成該執行緒執行的邏輯
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"：正在執行！"+i);
        }
    }
}

思考：執行緒物件呼叫 run方法和呼叫start方法區別？

執行緒物件呼叫run方法不開啟執行緒。僅是物件呼叫方法。執行緒物件呼叫start開啟執行緒，並讓jvm呼叫run方法在開啟的執行緒中執行。

1.5.1    繼承Thread類原理

我們為什麼要繼承Thread類，並呼叫其的start方法才能開啟執行緒呢？

繼承Thread類：因為Thread類用來描述執行緒，具備執行緒應該有功能。那為什麼不直接建立Thread類的物件呢？如下程式碼：

Thread t1 = new Thread();
t1.start();//這樣做沒有錯，但是該start呼叫的是Thread類中的run方法，而這個run方法沒有做什麼事情，更重要的是這個run方法中並沒有定義我們需要讓執行緒執行的程式碼。

建立執行緒的目的是什麼？

是為了建立程式單獨的執行路徑，讓多部分程式碼實現同時執行。也就是說執行緒建立並執行需要給定執行緒要執行的任務。

對於之前所講的主執行緒，它的任務定義在main函式中。自定義執行緒需要執行的任務都定義在run方法中。

Thread類run方法中的任務並不是我們所需要的，只有重寫這個run方法。既然Thread類已經定義了執行緒任務的編寫位置（run方法），那麼只要在編寫位置（run方法）中定義任務程式碼即可。所以進行了重寫run方法動作。

1.5.2    多執行緒的記憶體圖解

多執行緒執行時，到底在記憶體中是如何執行的呢？

以上個程式為例，進行圖解說明：

多執行緒執行時，在棧記憶體中，其實每一個執行執行緒都有一片自己所屬的棧記憶體空間。進行方法的壓棧和彈棧。

當執行執行緒的任務結束了，執行緒自動在棧記憶體中釋放了。但是當所有的執行執行緒都結束了，那麼程序就結束了。

1.5.3    獲取執行緒名稱

開啟的執行緒都會有自己的獨立執行棧記憶體，那麼這些執行的執行緒的名字是什麼呢？該如何獲取呢？既然是執行緒的名字，按照面向物件的特點，是哪個物件的屬性和誰的功能，那麼我們就去找那個物件就可以了。查閱Thread類的API文件發現有個方法是獲取當前正在執行的執行緒物件。還有個方法是獲取當前執行緒物件的名稱。既然找到了，我們就可以試試。

  •   Thread.currentThread()獲取當前執行緒物件
  •   Thread.currentThread().getName();獲取當前執行緒物件的名稱
class MyThread extends Thread {  //繼承Thread
    MyThread(String name){
        super(name);
    }
    //複寫其中的run方法
    public void run(){
        for (int i=1;i<=20 ;i++ ){
            System.out.println(Thread.currentThread().getName()+",i="+i);
        }
    }
}
class ThreadDemo {
    public static void main(String[] args)     {
        //建立兩個執行緒任務
        MyThread d = new MyThread();
        MyThread d2 = new MyThread();
        d.run();//沒有開啟新執行緒, 在主執行緒呼叫run方法
        d2.start();//開啟一個新執行緒，新執行緒呼叫run方法
    }
}
View Code

1.6     建立執行緒方式—實現Runnable介面

建立執行緒的另一種方法是宣告實現 Runnable 介面的類。該類然後實現 run 方法。然後建立Runnable的子類物件，傳入到某個執行緒的構造方法中，開啟執行緒。

為何要實現Runnable介面，Runable是啥玩意呢？繼續API搜尋。

檢視Runnable介面說明文件：Runnable介面用來指定每個執行緒要執行的任務。包含了一個 run 的無引數抽象方法，需要由介面實現類重寫該方法。

建立執行緒的步驟。

　　1、定義類實現Runnable介面。

　　2、覆蓋介面中的run方法。。

　　3、建立Thread類的物件

　　4、將Runnable介面的子類物件作為引數傳遞給Thread類的建構函式。

　　5、呼叫Thread類的start方法開啟執行緒。

  •  程式碼演示：
public class Demo02 {
    public static void main(String[] args) {
        //建立執行緒執行目標類物件
        Runnable runn = new MyRunnable();
        //將Runnable介面的子類物件作為引數傳遞給Thread類的建構函式
        Thread thread = new Thread(runn);
        Thread thread2 = new Thread(runn);
        //開啟執行緒
        thread.start();
        thread2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main執行緒：正在執行！"+i);
        }
    }
}
  •   自定義執行緒執行任務類
public class MyRunnable implements Runnable{

    //定義執行緒要執行的run方法邏輯
    @Override
    public void run() {
        
        for (int i = 0; i < 10; i++) {
            System.out.println("我的執行緒：正在執行！"+i);
        }
    }
}

1.6.1    實現Runnable的原理

為什麼需要定一個類去實現Runnable介面呢？繼承Thread類和實現Runnable介面有啥區別呢？

實現Runnable介面，避免了繼承Thread類的單繼承侷限性。覆蓋Runnable介面中的run方法，將執行緒任務程式碼定義到run方法中。

建立Thread類的物件，只有建立Thread類的物件才可以建立執行緒。執行緒任務已被封裝到Runnable介面的run方法中，而這個run方法所屬於Runnable介面的子類物件，所以將這個子類物件作為引數傳遞給Thread的建構函式，這樣，執行緒物件建立時就可以明確要執行的執行緒的任務。

1.6.2    實現Runnable的好處

第二種方式實現Runnable介面避免了單繼承的侷限性，所以較為常用。實現Runnable介面的方式，更加的符合面向物件，執行緒分為兩部分，一部分執行緒物件，一部分執行緒任務。繼承Thread類，執行緒物件和執行緒任務耦合在一起。一旦建立Thread類的子類物件，既是執行緒物件，有又有執行緒任務。實現runnable介面，將執行緒任務單獨分離出來封裝成物件，型別就是Runnable介面型別。Runnable介面對執行緒物件和執行緒任務進行解耦。

1.7     執行緒的匿名內部類使用

使用執行緒的內匿名內部類方式，可以方便的實現每個執行緒執行不同的執行緒任務操作。

  •  方式1：建立執行緒物件時，直接重寫Thread類中的run方法
new Thread() {
            public void run() {
                for (int x = 0; x < 40; x++) {
                    System.out.println(Thread.currentThread().getName()
                            + "...X...." + x);
                }
            }
        }.start();
  •  方式2：使用匿名內部類的方式實現Runnable介面，重新Runnable介面中的run方法
Runnable r = new Runnable() {
            public void run() {
                for (int x = 0; x < 40; x++) {
                    System.out.println(Thread.currentThread().getName()
                            + "...Y...." + x);
                }
            }
        };
        new Thread(r).start();

2  執行緒池

2.1     執行緒池概念

執行緒池，其實就是一個容納多個執行緒的容器，其中的執行緒可以反覆使用，省去了頻繁建立執行緒物件的操作，無需反覆建立執行緒而消耗過多資源。

我們詳細的解釋一下為什麼要使用執行緒池？

在java中，如果每個請求到達就建立一個新執行緒，開銷是相當大的。在實際使用中，建立和銷燬執行緒花費的時間和消耗的系統資源都相當大，甚至可能要比在處理實際的使用者請求的時間和資源要多的多。除了建立和銷燬執行緒的開銷之外，活動的執行緒也需要消耗系統資源。如果在一個jvm裡建立太多的執行緒，可能會使系統由於過度消耗記憶體或“切換過度”而導致系統資源不足。為了防止資源不足，需要採取一些辦法來限制任何給定時刻處理的請求數目，儘可能減少建立和銷燬執行緒的次數，特別是一些資源耗費比較大的執行緒的建立和銷燬，儘量利用已有物件來進行服務。

執行緒池主要用來解決執行緒生命週期開銷問題和資源不足問題。通過對多個任務重複使用執行緒，執行緒建立的開銷就被分攤到了多個任務上了，而且由於在請求到達時執行緒已經存在，所以消除了執行緒建立所帶來的延遲。這樣，就可以立即為請求服務，使用應用程式響應更快。另外，通過適當的調整執行緒中的執行緒數目可以防止出現資源不足的情況。

2.2     使用執行緒池方式--Runnable介面

通常，執行緒池都是通過執行緒池工廠建立，再呼叫執行緒池中的方法獲取執行緒，再通過執行緒去執行任務方法。                                                                                                                               

  •   Executors：執行緒池建立工廠類

  public static ExecutorService newFixedThreadPool(int nThreads)：返回執行緒池物件

  •   ExecutorService：執行緒池類

  Future<?> submit(Runnable task)：獲取執行緒池中的某一個執行緒物件，並執行

  •   Future介面：用來記錄執行緒任務執行完畢後產生的結果。執行緒池建立與使用
  •   使用執行緒池中執行緒物件的步驟：

  建立執行緒池物件

  建立Runnable介面子類物件

  提交Runnable介面子類物件

  關閉執行緒池

程式碼:

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //建立執行緒池物件
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2個執行緒物件
        //建立Runnable例項物件
        MyRunnable r = new MyRunnable();
        
        //自己建立執行緒物件的方式
        //Thread t = new Thread(r);
        //t.start(); ---> 呼叫MyRunnable中的run()
        
        //從執行緒池中獲取執行緒物件,然後呼叫MyRunnable中的run()
        service.submit(r);
        //再獲取個執行緒物件，呼叫MyRunnable中的run()
        service.submit(r);
        service.submit(r);
//注意：submit方法呼叫結束後，程式並不終止，是因為執行緒池控制了執行緒的關閉。將使用完的執行緒又歸還到了執行緒池中

//關閉執行緒池
        //service.shutdown();
    }
}
  •   Runnable介面實現類
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一個教練");
        
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教練來了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完後，教練回到了游泳池");
    }
}

2.3     使用執行緒池方式—Callable介面

  •   Callable介面：與Runnable介面功能相似，用來指定執行緒的任務。其中的call()方法，用來返回執行緒任務執行完畢後的結果，call方法可丟擲異常。
  •   ExecutorService：執行緒池類

  <T> Future<T> submit(Callable<T> task)：獲取執行緒池中的某一個執行緒物件，並執行執行緒中的call()方法

  •   Future介面：用來記錄執行緒任務執行完畢後產生的結果。執行緒池建立與使用
  •   使用執行緒池中執行緒物件的步驟：

  建立執行緒池物件

  建立Callable介面子類物件

  提交Callable介面子類物件

  關閉執行緒池

程式碼：

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //建立執行緒池物件
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2個執行緒物件
        //建立Callable物件
        MyCallable c = new MyCallable();
        
        //從執行緒池中獲取執行緒物件,然後呼叫MyRunnable中的run()
        service.submit(c);
        
        //再獲取個教練
        service.submit(c);
        service.submit(c);
//注意：submit方法呼叫結束後，程式並不終止，是因為執行緒池控制了執行緒的關閉。將使用完的執行緒又歸還到了執行緒池中

//關閉執行緒池
        //service.shutdown();
    }
}
  •  Callable介面實現類,call方法可丟擲異常、返回執行緒任務執行完畢後的結果
public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("我要一個教練:call");
        Thread.sleep(2000);
        System.out.println("教練來了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完後,教練回到了游泳池");
        return null;
    }
}

2.4     執行緒池練習：返回兩個數相加的結果

要求：通過執行緒池中的執行緒物件，使用Callable介面完成兩個數求和操作

  •   Future介面：用來記錄執行緒任務執行完畢後產生的結果。執行緒池建立與使用

  V get() 獲取Future物件中封裝的資料結果

程式碼:

public class ThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //建立執行緒池物件
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        
        //建立一個Callable介面子類物件
        //MyCallable c = new MyCallable();
        MyCallable c = new MyCallable(100, 200);
        MyCallable c2 = new MyCallable(10, 20);
        
        //獲取執行緒池中的執行緒，呼叫Callable介面子類物件中的call()方法, 完成求和操作
        //<Integer> Future<Integer> submit(Callable<Integer> task)
        // Future 結果物件
        Future<Integer> result = threadPool.submit(c);
        //此 Future 的 get 方法所返回的結果型別
        Integer sum = result.get();
        System.out.println("sum=" + sum);
        
        //再演示
        result = threadPool.submit(c2);
        sum = result.get();
        System.out.println("sum=" + sum);
        //關閉執行緒池(可以不關閉)
        
    }
}
  •   Callable介面實現類
public class MyCallable implements Callable<Integer> {
    //成員變數
    int x = 5;
    int y = 3;
    //構造方法
    public MyCallable(){
    }
    public MyCallable(int x, int y){
        this.x = x;
        this.y = y;
    }

    @Override
    public Integer call() throws Exception {
        return x+y;
    }
}

&n

相關推薦

Java學習多執行緒第一天

內容介紹 Thread 執行緒建立 執行緒池 執行緒狀態圖 1 多執行緒 1.1     多執行緒介紹 學習多執行緒之前，我們先要了解幾個關於多執行緒有關的概念。 程序：程序指正在執行的程式。確切的來說，當一個程式進入記憶體執行，即變成一個程序，程序是處於

Java學習多執行緒第二天

內容介紹  執行緒安全  執行緒同步  死鎖  Lock鎖  等待喚醒機制 1    多執行緒 1.1     執行緒安全 如果有多個執行緒在同時執行，而這些執行緒可能會同時執行這段程式碼。程式每

Java學習|多執行緒學習筆記

什麼是執行緒？     可以理解為程序中獨立執行的字任務。   使用多執行緒：     1.繼承Thread類：從原始碼可以看到，Thread累實現了Runnable介面。     &n

Java學習——多執行緒例子：李四王五

  package cys; public class Example9_2 { public static void main(String[] args) { // TODO Auto-generated method stub P

三十五、java學習--多執行緒程式設計

Java 多執行緒程式設計 Java 給多執行緒程式設計提供了內建的支援。 一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以併發多個執行緒，每條執行緒並行執行不同的任務。 多執行緒是多工的一種特別的形式，但多執行緒使用了更小的資源開銷。 這裡定義和執行緒相關的

Java學習--多執行緒案例--模擬火車票銷售(執行緒安全問題)

概述：火車票20張，三個視窗同時賣火車票 一.建立一個Runnable介面的實現類TicketSell,重寫run()方法 public class TicketSell implements

java的多執行緒學習，第一記

實現多執行緒有三種方法 1，繼承THread類 import com.sun.org.apache.xpath.internal.SourceTree; public class test{ //繼承Thread類並重寫run方法 public static class

【學習筆記】Java-Concurrent-多執行緒容器

BlockingQueue 阻塞佇列 高頻函式:   boolean put() 新增一個元素 沒有空間則一直阻塞等待   boolean add() 新增一個元素 沒有空間則丟擲IllegalStateException異常   boolean off

【學習筆記】Java-Concurrent-多執行緒測試模板

import java.util.concurrent.CountDownLatch; /** * 多執行緒測試模板 * * @author Mairuis * @date 2018/10/11 */ public class ConcurrentTest { public s

Java基礎學習——多執行緒之執行緒池

1.執行緒池介紹     執行緒池是一種執行緒使用模式。執行緒由於具有空閒（eg：等待返回值）和繁忙這種不同狀態，當數量過多時其建立、銷燬、排程等都會帶來開銷。執行緒池維護了多個執行緒，當分配可併發執行的任務時，它負責排程執行緒執行工作，執行完畢後執行緒不關閉而是返回執行緒池，

java的多執行緒學習，第三記

一，Java記憶體模型 Java記憶體模型規定了所有的記憶體變數都儲存在主記憶體中。每條執行緒中還有自己的工作記憶體，執行緒的工作記憶體中儲存了被該執行緒所使用到的變數（這些變數是從主記憶體中拷貝而來）。執行緒對變數的所有操作（讀取，賦值）都必須在工作記憶體中進行。不同執行緒之間也無法直接訪問對方工作記憶體

java的多執行緒學習，第四記

假如寫網路程式設計的程式，socket程式設計就是響應客戶程式設計的服務端。 public class ThreadPool { public static void main(String[] args) throws IOException { ServerSock

作為一個java初學者，改如何學習多執行緒？

多執行緒相對於其他 Java 知識點來講，有一定的學習門檻，並且瞭解起來比較費勁。在平時工作中如若使用不當會出現資料錯亂、執行效率低（還不如單執行緒去執行）或者死鎖程式掛掉等等問題，所以掌握瞭解多執行緒至關重要。 1、為什麼要使用多執行緒 首先，你學習Java多執行緒，得知道為什麼要使

java多執行緒第一篇——多執行緒基礎知識點總結

程序與執行緒一個正在作業系統中執行的 exe 程式理解成一個“程序”，執行緒可以理解成是在程序中獨立執行的子任務。一個QQ.exe 執行時是一個程序， 其中：好友視訊執行緒、下載檔案執行緒、傳輸資料執行緒、傳送表 情執行緒等。  2.main方法是一個執行緒3.執行緒是一個子

共同學習Java原始碼-多執行緒與併發-ConcurrentHashMap(一)

ConcurrentHashMap是每個Java學習者必看的類 public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V&

Java 建立多執行緒

1、繼承java.lang.Thread方式 執行start方法:MyThread的run就會被執行 程式碼片段： import java.util.Scanner; public class Main { public static void main(String[] a

java多執行緒系列翻譯之java併發/多執行緒教程

原文地址：http://tutorials.jenkov.com/java-concurrency/index.html 以前計算機都是單核，同時只能執行一個程式。之後出現了多重任務處理，這意味著計算機同時可以處理多個程式（又名任務或流程）。但這不是真正的“同時執行”，只是單個CPU被多個程式共

java隨筆——多執行緒

//多執行緒 //第一種方法 package we; public class me { public static void main(String[] args) { My p=new My(); p.start();//啟用多執行緒 while(true)

java中多執行緒一定快嗎?看完就知道!!!

理解上下文切換   即使是單核處理器也支援多執行緒執行程式碼,CPU通過每個執行緒分配CPU時間片來實現這個機制.時間片是CPU分配給多個執行緒的時間,因為時間片非常短,所以CPU通過不停的切換執行緒執行,讓我們感覺多個執行緒是同時執行的,時間片一般是幾十毫秒(ms).  

java初學多執行緒

一、實現多執行緒的兩種方式 　　1.繼承Tread類 　　2.實現Runnable介面 　　3.匿名內部類 二、具體實現 　　1.繼承Tread類 　　 1 public class Demo2_Thread { 2 public static void main(String