JAVA并行-1.Java線程操作

1.進程和線程

進程（Process）是計算機中的程序關于某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統的基礎。
面向進程的程序設計中，進程是程序的基本執行實體。
面向線程的程序設計中，進程是線程的容器。
進程是程序的實體，而程序是指令，數據，以及其組織形式的描述。

2.Java中的線程操作

2.1新建線程

2.1.2Thread線程類

關鍵字new創建一個線程對象，然后調用對象的start()方法：

Thread t1 = new Thread();
t1.start();

線程對象Thread有一個run()方法，start()方法會新建一個線程并讓這個線程執行run()方法。
直接使用run()方法，會在當前線程中串行調用run()方法。

2.1.3Runnable接口

也可以用Runnable接口新建線程，它只有一個run()方法，而且默認的Thread.run()就是調用內部的Runnable接口，因此使用Runnable更合理。

public interface Runnable {
    public abstract void run();
}

Thread類有一個構造方法：

public Thread(Runnable target)

默認的Thread.start()方法調用的時候，新的線程就會執行Runnable.run()方法：

public void run(){
    if(target != null){
        target.run();
    }
}

以下代碼實現Runnable接口，并將該實例傳入Thread，避免重載Thread.run()：

public class CreateThread implements Runnable{
    public static void main(String[] args){
        Thread t1 = new Thread(new CreateThread());
        t1.start();
    }

    @Override
    public void run(){
        System.out.println("Here is a Runnable！");
    }
}

2.2 終止線程

一般來說，線程在執行完成之后就會結束。但是也可以手動關閉線程。

2.2.1Thread.stop()

Thread.stop()方法可以結束線程，但是是直接終止線程，并立即釋放這個線程所持有的鎖。
該方法會導致數據不一致的問題，因此已經被標注為廢棄，不要使用。

例如，以下代碼沒有錯誤信息，但是結果不一致了：

public class StopThreadUnsafe {
    public static User u = new User();

    public static class User {
        int id;
        String name;

        public User() {
            id = 0;
            name = "0";
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "User [id = " + id + ", name = " + name + "]";
        }
    }

    public static class ChangeObjectThread extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (u) {
                    int v = (int) (System.currentTimeMillis() / 1000);
                    u.setId(v);
                    // do something else
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    u.setName(String.valueOf(v));
                }
                Thread.yield();
            }
        }
    }

    public static class ReadObjectThread extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (u) {
                    if (u.getId() != Integer.parseInt(u.getName())) {
                        System.out.println(u.toString());
                    }
                }
                Thread.yield();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ReadObjectThread().start();
        while (true) {
            ChangeObjectThread t = new ChangeObjectThread();
            t.start();
            Thread.sleep(150);
            t.stop();
        }
    }
}

如果要安全的停止一個線程，可以自己決定停止線程的時機，例如將前例中的CreateObjectThread線程中增加一個stopMe()方法：

public static class ChangeObjectThread extends Thread {
        volatile boolean stopme = false;
        
        public void stopMe() {
            stopme = true;
        }
        
        @Override
        public void run() {
            while (true) {
                if(stopme) {
                    System.out.println("exit by stop me");
                    break;
                }
                synchronized (u) {
                    int v = (int) (System.currentTimeMillis() / 1000);
                    u.setId(v);
                    // do something else
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    u.setName(String.valueOf(v));
                }
                Thread.yield();
            }
        }
    }

2.3 中斷線程

中斷線程并不會使線程立即退出，而是給線程發送通知，線程接到通知后的操作由線程執行決定。
JVM中于線程中斷有關的方法如下：
- Thread.interrupt()，是一個實例方法，通知線程中斷，即設置中斷標志位。中斷標志位表示當前線程已經被中斷了。
- Thread.isInterrupted()，也是一個實例方法，判斷當前線程是否有中斷（通過判斷中斷標志位）
- Thread.interrupted()，是一個靜態方法，用來判斷當前線程的中斷狀態，同時清除當前線程的中斷狀態。
方法簽名為：

public void Thread.interrupt()  //中斷線程
public boolean Thread.isInterrupted()  //判斷線程是否中斷
public static boolean Thread.interrupted() //判斷是否中斷，并清除當前中斷狀態

注意：中斷后需要增加中斷處理代碼，不然中斷不會發生作用。

Thread.sleep()函數

在循環體中，出現了sleep()或者wait()等操作，需要通過中斷來識別。wait()在下一小節介紹，這里介紹sleep()方法。
Thread.sleep()函數的作用是讓當前線程休眠若干時間，其函數簽名為：

public static native void sleep(long millis) throws InterruptedException

它會拋出一個InterruptedException異常，不是運行時異常，程序必須捕獲并處理他。當線程在sleep()休眠中被中斷，這個異常就會產生。
注意：Thread.sleep()方法因為中斷拋出異常時，會清除中斷標記，如果不加處理，在下一次循環開始時，就無法捕捉這個中斷，所以在異常處理中需要再次設置中斷標記位。

2.4 等待（wait）和通知（notify）

等待（wait）方法和通知（notify）方法是為了支持多線程的協作而存在的。
這兩個方法是在Object類中，即任何對象都能調用這兩個方法。
Object.wait()方法不能隨便調用，需要包含在對應的synchronzied語句中。
wait()和notify()方法都需要首先獲得目標對象的一個監視器。
Object.wait()和Thread.sleep()方法都能讓線程等待若干時間，區別為：
- wait()方法可以被喚醒，sleep()方法需要等待時間結束
- wait()方法會釋放目標對象的鎖，而sleep()方法不會釋放任何資源
其方法簽名為：

public final void wait() throws InterruptedException
public final native void notify()

線程調用object.wait()方法，它會進入到object的等待隊列。當object.notify()方法被調用時，對象會在線程隊列中，隨機選擇一個線程，將其喚醒。
注意：這個選擇是非公平的，完全隨機。
使用例子：

package temp;

public class SimpleWN {
    final static Object object = new Object();
    public static class T1 extends Thread{
        public void run() {
            //獲得object對象鎖
            synchronized(object) {
                System.out.println(System.currentTimeMillis() + ": T1 Start!");
                try {
                    System.out.println(System.currentTimeMillis() + ": T1 is wait for obejct!");
                    // 釋放object的對象鎖
                    object.wait();
                }
                catch(InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + ": T1 is end");
            }
        }
    }
    
    public static class T2 extends Thread {
        public void run() {
            synchronized(object) {
                System.out.println(System.currentTimeMillis() + ": T2 Start!");
                System.out.println("notify one thread!");
                // 釋放object對象鎖
                object.notify();
                System.out.println(System.currentTimeMillis() + ": T2 end!");
                try {
                    // 休眠結束之后，才釋放對象鎖，T1才能繼續執行
                    Thread.sleep(2000);
                }
                catch(InterruptedException e) {
                    e.printStackTrace();
                }
                
            }
        }
    }
    
    public static void main(String[] args) {
        Thread t1 = new T1();
        Thread t2 = new T2();
        t1.start();
        t2.start();
    }
}

2.5 掛起（suspend）和繼續執行（resume）線程

被掛起（suspend）的線程，需要等到resume()操作后才能繼續執行
這兩個方法已經標注為廢棄，不建議使用
廢棄的原因是suspend()方法在導致線程暫停的同時，并不會釋放任何鎖資源，其他任何要范圍被它暫時使用的鎖，都無法正常運行。而被掛起的線程狀態仍然是Runnable，影響對系統狀態的判斷。

以下例子會導致系統鎖死：

public class BadSuspend {
    public static Object u = new Object();
    static ChangeObjectThread t1 = new ChangeObjectThread("t1");
    static ChangeObjectThread t2 = new ChangeObjectThread("t2");
    
    public static class ChangeObjectThread extends Thread{
        public ChangeObjectThread(String name) {
            super.setName(name);
        }
        
        @Override
        public void run() {
            synchronized(u) {
                System.out.println("in " + getName());
                Thread.currentThread().suspend();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException{
        // t1
        t1.start();
        Thread.sleep(100);
        t2.start();
        t1.resume();
        // 此時t2的狀態依然是RUNNABLE
        t2.resume();
        t1.join();
        t2.join();
    }
}

為了達到相同的目的，可以用如下方法（使用wait()和notify()）：

public class GoodSuspend {
    public static Object u = new Object();
    
    public static class ChangeObjectThread extends Thread{
        // 標記變量，表明線程是否被掛起
        volatile boolean suspendme = false;

        public void suspendMe() {
            suspendme = true;
        }
        
        public void resumeMe() {
            suspendme = false;
            synchronized (this){
                notify();
            }
        }
        
        @Override
        public void run() {
            while(true) {
                synchronized(this) {
                    // 檢查線程是否被掛起
                    while(suspendme) {
                        try{
                            wait();
                        }
                        catch(InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                synchronized(u) {
                    System.out.println("in ChangeObjectThread");
                }
                Thread.yield();
            }
        }
    }
    
    public static class ReadObjectThread extends Thread{
        @Override
        public void run() {
            while(true) {
                synchronized(u) {
                    System.out.println("in ReadObjectThread");
                }
                Thread.yield();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException{
        // 實例化線程對象
        ChangeObjectThread t1 = new ChangeObjectThread();
        ReadObjectThread t2 = new ReadObjectThread();
        // 運行線程對象
        t1.start();
        t2.start();
        Thread.sleep(1000);
        // 掛起t1線程
        t1.suspendMe();
        System.out.println("suspend t1 2 sec");
        Thread.sleep(2000);
        System.out.println("resume t1");
        t1.resumeMe();
    }
}

2.6 等待線程結束（join）和謙讓（yield）

join簽名如下，有兩種：

// 阻塞當前線程，直到目標線程執行完畢
public final void join() throws InterruptedException

 // 最多等待millies毫秒，之后繼續執行
public final synchronised void join(long millis) throws InterruptedException

join 的本質是調用線程wait()方法在當前線程對象實例上，它使得調用線程在當前線程對象上等待，被等待的線程會在調用結束前調用notifyAll()通知所有等待線程繼續執行。JDK中join()實現的核心代碼為：

while(isAlive()){
  wati(0);
}

基礎join()例子：

package temp;

public class JoinMain {
    public volatile static int i = 0;

    public static class AddThread extends Thread {
        @Override
        public void run() {
            for (; i < 1000000; i++)
                ;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AddThread at = new AddThread();
        System.out.println(i);
        at.start();
        System.out.println(i);
        at.join();
        // join()保證最后輸出的是1000000
        System.out.println(i);
    }
}

yield()方法會使當前線程讓出CPU，重新進行資源分配。

?著作權歸作者所有,轉載或內容合作請聯系作者

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
沈念sama閱讀 227,367評論 6贊 532
死咒
序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
沈念sama閱讀 98,001評論 3贊 413
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
開封第一講書人閱讀 175,213評論 0贊 373
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長。經常有香客問我，道長，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 62,535評論 1贊 308
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
茶點故事閱讀 71,317評論 6贊 405
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著，像睡著了一般。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發上，一...
開封第一講書人閱讀 54,868評論 1贊 321
城市分裂傳說
那天，我揣著相機與錄音，去河邊找鬼。笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。我是一名探鬼主播，決...
沈念sama閱讀 42,963評論 3贊 440
雙鴛鴦連環套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
開封第一講書人閱讀 42,090評論 0贊 285
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
沈念sama閱讀 48,599評論 1贊 331
?護林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內容為張勛視角年9月15日...
茶點故事閱讀 40,549評論 3贊 354
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
茶點故事閱讀 42,712評論 1贊 367
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
沈念sama閱讀 38,233評論 5贊 356
?日本核電站爆炸內幕
正文年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
茶點故事閱讀 43,961評論 3贊 346
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 34,353評論 0贊 25
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 35,607評論 1贊 281
情欲美人皮
我被黑心中介騙來泰國打工，沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。一個月前我還...
沈念sama閱讀 51,321評論 3贊 389
代替公主和親
正文我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
茶點故事閱讀 47,686評論 2贊 370

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

JAVA并行-1.Java線程操作

JAVA并行-1.Java線程操作

1.進程和線程

2.Java中的線程操作

2.1新建線程

2.1.2Thread線程類

2.1.3Runnable接口

2.2 終止線程

2.2.1Thread.stop()

2.3 中斷線程

Thread.sleep()函數

2.4 等待（wait）和通知（notify）

2.5 掛起（suspend）和繼續執行（resume）線程

2.6 等待線程結束（join）和謙讓（yield）

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

JAVA并行-1.Java線程操作

1.進程和線程

2.Java中的線程操作

2.1新建線程

2.1.2Thread線程類

2.1.3Runnable接口

2.2 終止線程

2.2.1Thread.stop()

2.3 中斷線程

Thread.sleep()函數

2.4 等待（wait）和通知（notify）

2.5 掛起（suspend）和繼續執行（resume）線程

2.6 等待線程結束（join）和謙讓（yield）

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频