實戰Java高併發程序設計-03 Java線程

概念

線程的生命週期

線程的狀態定義在 java.lang.Thread.State 中

NEW

創建狀態並未執行，通過start()方法開始線程執行，進入RUNNABLE

RUNNABLE

運行狀態

BLOCKED

阻塞狀態，如果在執行的過程中遇到了synchronize 關鍵字標註的同步塊，就會進入阻塞狀態

WAITING

等待狀態，表示線程進入了等待狀態，直到notify()方法執行通知後，線程繼續進入運行狀態
TIMED_WAITING
等待狀態，同上一樣，只不過加上了一個等待的時間限制.
TERMINATED
終止狀態

線程的基本操作

新建線程與啓動

主線程

package t;

public class M {

    public static void main(String[] args) {
        Thread t = new Thread(new MyThread());
        //t.start();
        t.run();
        for(int i = 0 ;i < 5 ; i++){
            System.out.println("main : " + i);
        }
    }

}

子線程

package t;

public class MyThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0 ; i < 5 ; i++){
            System.out.println("other : " + i);
        }
    }

}

注意：啓動方法時start ，而不是 run 。 如果通過run就是串行話的調用，打印結果永遠都是

other : 0
other : 1
other : 2
other : 3
other : 4
main : 0
main : 1
main : 2
main : 3
main : 4

而使用start纔是開啓線程，打印結果隨機產生，是因爲線程的執行情況，有時候主線程執行的比較快，也適合子線程執行的比較快

線程終止

正常情況下，線程執行完畢就會終止，不用手動關閉。
但是有時候也會有一些情況下是有例外的，比如線程本身就在一個無限循環裏面執行

關閉線程在jdk中提供了一個stop方法，但是這個方法已經過時了，因爲這個方法太暴力，直接關閉線程，不管線程是否執行完畢。

線程同步synchronize

//打印類
public class Print {
    public synchronized void prt(){
        for(int i = 0 ; i < 5  ; i++){
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }
}
//線程類
public class Th1 implements Runnable{

    private Print p;

    public Th1(Print p) {
        this.p = p;
    }

    @Override
    public void run() {
        p.prt();
    }
}
//Main方法類
public class M {

    public static void main(String[] args) {

        Print p = new Print();
        new Thread(new Th1(p)).start();
        new Thread(new Th1(p)).start();
    }

}

上面這段代碼 直接執行 打印結果 如下，ID並不連續，一會打印線程9 ，一會打印 線程10

Thread-0 : 0
Thread-1 : 0
Thread-0 : 1
Thread-1 : 1
Thread-0 : 2
Thread-1 : 2
Thread-0 : 3
Thread-1 : 3
Thread-0 : 4
Thread-1 : 4

而給 Print類的prt 方法 加上 synchronized 後 發現 打印是非常規律的，一個線程完全打印完畢，纔會打印另外一個線程，也意味着 一個線程執行完畢，另外一個線程才能進行執行

等待與通知

在調用wait的時候，線程自動釋放其佔有的對象鎖，同時不會去申請對象鎖。當線程被喚醒的時候，它纔再次獲得了去獲得對象鎖的權利。
notify喚醒在等待該對象同步鎖的線程(只喚醒一個,如果有多個在等待),注意的是在調用此方法的時候，並不
能確切的喚醒某一個等待狀態的線程，而是由JVM確定喚醒哪個線程，而且不是按優先級
notifyAll喚醒所有等待的線程

package c;

public class MyThreadFactory {

    public static void main(String[] args) {
        MyThreadFactory factory = new MyThreadFactory();
        factory.startThreadA();
        factory.startThreadB();
        factory.startThreadC();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        factory.startWakenThread();
    }

    public MyThreadFactory() {
    }

    /**
     * 對象鎖
     */
    private final Object object = new Object();

    /**
     * 該線程作爲一個喚醒線程
     */
    public void startWakenThread() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("喚醒線程開始執行...");
                    // 首先釋放線程A
                    quitThreadA();
                }
            }
        });
        t.start();
    }

    /**
     * 啓動線程A
     */
    public void startThreadA() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("線程A開始等待...");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("線程A結束...");
                    // 線程A結束後，暫停2秒釋放線程B
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    quitThreadB();
                }
            }
        });
        t.start();
    }

    /**
     * 啓動線程B
     */
    public void startThreadB() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("線程B開始等待...");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("線程B結束...");
                    // 線程B結束後，暫停2秒釋放線程C
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    quitThreadC();
                }
            }
        });
        t.start();
    }

    /**
     * 啓動線程C
     */
    public void startThreadC() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("線程C開始等待...");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("線程C結束...");

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("所有線程執行完畢！");
                }
            }
        });
        t.start();
    }

    /**
     * 線程A退出等待
     */
    private void quitThreadA() {
        object.notify();
    }

    /**
     * 線程B退出等待
     */
    private void quitThreadB() {
        object.notify();
    }

    /**
     * 線程C退出等待
     */
    private void quitThreadC() {
        object.notify();
    }
}

等待線程結束(join)和謙讓(yield)

join表示在兩個線程執行的過程中A線程執行某一項工作，B線程執行一項工作依賴A線程執行初始化完畢之後才能開始執行，則可以用的join
yield表示當前線程讓出cpu執行，但是讓出線程之後不代表這個線程就不執行了，而是由當前線程與其他線程進行資源的搶奪，當前線程能否再次被分配到就是隨機的

線程的優先級

/**
* The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY = 1;

/**
* The default priority that is assigned to a thread.
*/
public final static int NORM_PRIORITY = 5;

/**
 * The maximum priority that a thread can have.
 */
public final static int MAX_PRIORITY = 10;