Java多線程學習：線程基礎(一)

時間 2019-11-07

標籤 java 多線程學習線程基礎欄目 Java 简体版

原文原文鏈接

1、線程的基本概念

線程理解：線程是一個程序裏面不一樣的執行路徑java

　　每個分支都叫作一個線程，main()叫作主分支，也叫主線程。多線程

　　程只是一個靜態的概念，機器上的一個.class文件，機器上的一個.exe文件，這個叫作一個進程。程序的執行過程都是這樣的：首先把程序的代碼放到內存的代碼區裏面，代碼放到代碼區後並無立刻開始執行，但這時候說明了一個進程準備開始，進程已經產生了，但尚未開始執行，這就是進程，因此進程實際上是一個靜態的概念，它自己就不能動。日常所說的進程的執行指的是進程裏面主線程開始執行了，也就是main()方法開始執行了。進程是一個靜態的概念，在咱們機器裏面實際上運行的都是線程。學習

　　Windows操做系統是支持多線程的，它能夠同時執行不少個線程，也支持多進程，所以Windows操做系統是支持多線程多進程的操做系統。Linux和Uinux也是支持多線程和多進程的操做系統。DOS就不是支持多線程和多進程了，它只支持單進程，在同一個時間點只能有一個進程在執行，這就叫單線程。this

　　CPU難道真的很神通廣大，可以同時執行那麼多程序嗎？不是的，CPU的執行是這樣的：CPU的速度很快，一秒鐘能夠算好幾億次，所以CPU把本身的時間分紅一個個小時間片，我這個時間片執行你一會，下一個時間片執行他一會，再下一個時間片又執行其餘人一會，雖然有幾十個線程，但同樣能夠在很短的時間內把他們統統都執行一遍，但對咱們人來講，CPU的執行速度太快了，所以看起來就像是在同時執行同樣，但實際上在一個時間點上，CPU只有一個線程在運行。spa

學習線程首先要理清楚三個概念：操作系統

進程：進程是一個靜態的概念線程
線程：一個進程裏面有一個主線程叫main()方法，是一個程序裏面的，一個進程裏面不一樣的執行路徑。code
在同一個時間點上，一個CPU只能支持一個線程在執行。由於CPU運行的速度很快，所以咱們看起來的感受就像是多線程同樣。對象

　　什麼纔是真正的多線程？若是你的機器是雙CPU，或者是雙核，這確確實實是多線程。繼承

2、線程的建立和啓動

　　在JAVA裏面，JAVA的線程是經過java.lang.Thread類來實現的，每個Thread對象表明一個新的線程。建立一個新線程出來有兩種方法：第一個是從Thread類繼承，另外一個是實現接口runnable。VM啓動時會有一個由主方法(public static void main())所定義的線程，這個線程叫主線程。能夠經過建立Thread的實例來建立新的線程。你只要new一個Thread對象，一個新的線程也就出現了。每一個線程都是經過某個特定的Thread對象所對應的方法run()來完成其操做的，方法run()稱爲線程體。

範例1：使用實現Runnable接口建立和啓動新線程

開闢一個新的線程來調用run方法

package cn.galc.test;

public class TestThread1{
    public static void main(String args[]){
        Runner1 r1 = new Runner1();//這裏new了一個線程類的對象出來
        //r1.run();//這個稱爲方法調用，方法調用的執行是等run()方法執行完以後纔會繼續執行main()方法
        Thread t = new Thread(r1);//要啓動一個新的線程就必須new一個Thread對象出來
        //這裏使用的是Thread(Runnable target) 這構造方法
        t.start();//啓動新開闢的線程，新線程執行的是run()方法，新線程與主線程會一塊兒並行執行
        for(int i=0;i<10;i++){
            System.out.println("maintheod："+i);
        }
    }
}
/*定義一個類用來實現Runnable接口，實現Runnable接口就表示這個類是一個線程類*/
class Runner1 implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("Runner1："+i);
        }
    }
}

多線程程序執行的過程以下所示：

不開闢新線程直接調用run方法

運行結果以下：

範例2：繼承Thread類，並重寫其run()方法建立和啓動新的線程

package cn.galc.test;

/*線程建立與啓動的第二種方法：定義Thread的子類並實現run()方法*/
public class TestThread2{
    public static void main(String args[]){
        Runner2 r2 = new Runner2();
        r2.start();//調用start()方法啓動新開闢的線程
        for(int i=0;i<=10;i++){
            System.out.println("mainMethod："+i);
        }
    }
}
/*Runner2類從Thread類繼承
經過實例化Runner2類的一個對象就能夠開闢一個新的線程
調用從Thread類繼承來的start()方法就能夠啓動新開闢的線程*/
class Runner2 extends Thread{
    public void run(){//重寫run()方法的實現
        for(int i=0;i<=10;i++){
            System.out.println("Runner2："+i);
        }
    }
}

　　使用實現Runnable接口和繼承Thread類這兩種開闢新線程的方法的選擇應該優先選擇實現Runnable接口這種方式去開闢一個新的線程。由於接口的實現能夠實現多個，而類的繼承只能是單繼承。所以在開闢新線程時可以使用Runnable接口就儘可能不要使用從Thread類繼承的方式來開闢新的線程。

3、線程狀態轉換

3.1.線程控制的基本方法

3.2. sleep/join/yield方法介紹

sleep方法的應用範例：

package cn.galc.test;

import java.util.*;

public class TestThread3 {
    public static void main(String args[]){
        MyThread thread = new MyThread();
        thread.start();//調用start()方法啓動新開闢的線程
        try {
            /*Thread.sleep(10000);
            sleep()方法是在Thread類裏面聲明的一個靜態方法，所以可使用Thread.sleep()的格式進行調用
            */
            /*MyThread.sleep(10000);
            MyThread類繼承了Thread類，天然也繼承了sleep()方法，因此也可使用MyThread.sleep()的格式進行調用
            */
            /*靜態方法的調用能夠直接使用「類名.靜態方法名」
              或者「對象的引用.靜態方法名」的方式來調用*/
            MyThread.sleep(10000);
            System.out.println("主線程睡眠了10秒種後再次啓動了");
            //在main()方法裏面調用另一個類的靜態方法時，須要使用「靜態方法所在的類.靜態方法名」這種方式來調用
            /*
            因此這裏是讓主線程睡眠10秒種
            在哪一個線程裏面調用了sleep()方法就讓哪一個線程睡眠，因此如今是主線程睡眠了。
            */
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //thread.interrupt();//使用interrupt()方法去結束掉一個線程的執行並非一個很好的作法
        thread.flag=false;//改變循環條件，結束死循環
        /**
         * 當發生InterruptedException時，直接把循環的條件設置爲false便可退出死循環，
         * 繼而結束掉子線程的執行，這是一種比較好的結束子線程的作法
         */
        /**
         * 調用interrupt()方法把正在運行的線程打斷
        至關因而主線程一盆涼水潑上去把正在執行分線程打斷了
        分線程被打斷以後就會拋InterruptedException異常，這樣就會執行return語句返回，結束掉線程的執行
        因此這裏的分線程在執行完10秒鐘以後就結束掉了線程的執行
         */
    }
}

class MyThread extends Thread {
    boolean flag = true;// 定義一個標記，用來控制循環的條件

    public void run() {
        /*
         * 注意：這裏不能在run()方法的後面直接寫throw Exception來拋異常， 
         * 由於如今是要重寫從Thread類繼承而來的run()方法,重寫方法不能拋出比被重寫的方法的不一樣的異常。
         *  因此這裏只能寫try……catch()來捕獲異常
         */
        while (flag) {
            System.out.println("==========" + new Date().toLocaleString() + "===========");
            try {
                /*
                 * 靜態方法的調用格式通常爲「類名.方法名」的格式去調用 在本類中聲明的靜態方法時調用時直接寫靜態方法名便可。 固然使用「類名.方法名」的格式去調用也是沒有錯的
                 */
                // MyThread.sleep(1000);//使用「類名.方法名」的格式去調用屬於本類的靜態方法
                sleep(1000);//睡眠的時若是被打斷就會拋出InterruptedException異常
                // 這裏是讓這個新開闢的線程每隔一秒睡眠一次，而後睡眠一秒鐘後再次啓動該線程
                // 這裏在一個死循環裏面每隔一秒啓動一次線程，每一個一秒打印出當前的系統時間
            } catch (InterruptedException e) {
                /*
                 * 睡眠的時一盤冷水潑過來就有可能會打斷睡眠 
                 * 所以讓正在運行線程被一些意外的緣由中斷的時候有可能會拋被打擾中斷(InterruptedException)的異常
                 */
                return;
                // 線程被中斷後就返回，至關因而結束線程
            }
        }
    }
}

運行結果：

join方法的使用範例：

package cn.galc.test;

public class TestThread4 {
    public static void main(String args[]) {
        MyThread2 thread2 = new MyThread2("mythread");
        // 在建立一個新的線程對象的同時給這個線程對象命名爲mythread
        thread2.start();// 啓動線程
        try {
            thread2.join();// 調用join()方法合併線程，將子線程mythread合併到主線程裏面
            // 合併線程後，程序的執行的過程就至關因而方法的調用的執行過程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am main Thread");
        }
    }
}

class MyThread2 extends Thread {
    MyThread2(String s) {
        super(s);
        /*
         * 使用super關鍵字調用父類的構造方法 
         * 父類Thread的其中一個構造方法：「public Thread(String name)」 
         * 經過這樣的構造方法能夠給新開闢的線程命名，便於管理線程
         */
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("I am a\t" + getName());
            // 使用父類Thread裏面定義的
            //public final String getName()，Returns this thread's name.
            try {
                sleep(1000);// 讓子線程每執行一次就睡眠1秒鐘
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

運行結果：

yield方法的使用範例：

package cn.galc.test;

public class TestThread5 {
    public static void main(String args[]) {
        MyThread3 t1 = new MyThread3("t1");
        /* 同時開闢了兩條子線程t1和t2，t1和t2執行的都是run()方法 */
        /* 這個程序的執行過程當中總共有3個線程在並行執行，分別爲子線程t1和t2以及主線程 */
        MyThread3 t2 = new MyThread3("t2");
        t1.start();// 啓動子線程t1
        t2.start();// 啓動子線程t2
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am main Thread");
        }
    }
}

class MyThread3 extends Thread {
    MyThread3(String s) {
        super(s);
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(getName() + "：" + i);
            if (i % 2 == 0) {
                yield();// 當執行到i能被2整除時當前執行的線程就讓出來讓另外一個在執行run()方法的線程來優先執行
                /*
                 * 在程序的運行的過程當中能夠看到，
                 * 線程t1執行到(i%2==0)次時就會讓出線程讓t2線程來優先執行 
                 * 而線程t2執行到(i%2==0)次時也會讓出線程給t1線程優先執行
                 */
            }
        }
    }
}

運行結果以下：