java多線程（2）Thread的實例方法

ispring 發布于2019-08-16 10:54 / 1963人閱讀

摘要：之前有簡單介紹過多線程的使用，已經類和類，為了更好地理解多線程，本文就進行詳細的分析。方法是強制停止線程的執行，是非安全的，不要使用此方法。比較簡單，獲取線程的名稱。和方法的作用是等待線程執行完成，可以設置最長等待時間。

之前有簡單介紹過java多線程的使用，已經Thread類和Runnable類，為了更好地理解多線程，本文就Thread進行詳細的分析。

start()

start方法是開啟線程的方法，使用后java會創建一個新的線程執行run里的方法。這是一個小demo：

        for(int i=0;i<3;i++){
            Thread t= new Thread(new Runnable() {
                @Override
                public void run() {
            System.out.println(Thread.currentThread().getName()+" start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            System.out.println(Thread.currentThread().getName()+" end");
                }
            });
            t.start();
        }
        System.out.println("it is over");

執行結果：
it is over
Thread-1 start
Thread-0 start
Thread-2 start
Thread-0 end
Thread-1 end
Thread-2 end

由于多線程是有隨機性的，所以每次的結果可能都不一樣，這一點也是我們需要注意的，線程的執行順序和調用順序并不一致。

run()

run方法就是調用Thread設置的Runnable的run方法，將上面的demo進行修改：

        for(int i=0;i<3;i++){
            Thread t= new Thread(new Runnable() {
                
                @Override
                public void run() {
            System.out.println(Thread.currentThread().getName()+" start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            System.out.println(Thread.currentThread().getName()+" end");
                }
            });
            t.run();
        }
        System.out.println("it is over");

執行結果：
main start
main end
main start
main end
main start
main end
it is over
run方法的直接結果和start有很大的差別，完全是按順序執行，并沒有開啟新線程。

stop()

stop方法是強制停止線程的執行，是非安全的，不要使用此方法。在調用stop時，會對鎖定的資源進行釋放，但這種釋放是非一致的,容易引起程序問題。如果想要控制線程的停止，可以使用自定義變量來判斷或者isInterrupted()方法:

class Thread1 extends Thread {
    @Override
    public void run() {
        //判斷線程體是否運行
        while (!isInterrupted()) {
            // Do Something
        }
    }    
}

interrupt()

interrupt的作用是通知線程，你已經被中斷的，但具體的中斷執行需要在線程自定義處理，甚至你可以不理會繼續執行。具體的中孤單是會線程執行join、wait、sleep方法時，拋出InterruptedException。

Thread t1 = new Thread(new Runnable() {
                @Override
                public  void  run() {
                        System.out.println(Thread.currentThread().getName()+" start");
                        try {
                            for(int i=0;i<100000;i++){
                                System.out.println(i+"");
                                Thread.sleep(1);
                            }
                        } catch (InterruptedException e) {
                            System.out.println("the thread is interrupted");//可以在這里做資源釋放，日志記錄等
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+" end");
                    }
            });
            t1.start();
            Thread.sleep(100);
            t1.interrupt();

執行結果：

65
66
67
68
the thread is interrupted
java.lang.InterruptedException: sleep interrupted
Thread-0 end
    at java.lang.Thread.sleep(Native Method)
    at com.wk.aqi.act.Test$1.run(Test.java:23)
    at java.lang.Thread.run(Thread.java:745)

isInterrupted()

判斷線程是否中斷，在執行上面的interrupt方法后，會return true。

setPriority(int newPriority)和getPriority()

設置線程的優先級和獲取線程的優先級，cpu分配的資源給側重給priority高的線程。

Thread t1 = new Thread(new Runnable() {
                @Override
                public  void  run() {
                        long t = System.currentTimeMillis();
                        System.out.println(Thread.currentThread().getName()+" start");
                        for(int i=0;i<1000;i++){
                            try {
                                Thread.sleep(1);
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                        System.out.println(Thread.currentThread().getName()+" t1 end "+(System.currentTimeMillis()-t));
                    }
            });
            Thread t2 = new Thread(new Runnable() {
                @Override
                public  void  run() {
                    long t = System.currentTimeMillis();
                    System.out.println(Thread.currentThread().getName()+" start");
                    for(int i=0;i<1000;i++){
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName()+" t2 end "+(System.currentTimeMillis()-t));
                }
            });
            t1.setPriority(10);
            t2.setPriority(1);
            t2.start();
            t1.start();

執行結果：

Thread-0 start
Thread-1 start
Thread-0 t1 end 1357
Thread-1 t2 end 1371

在優先級一樣的情況下，t1和t2是幾乎同時完成的，在優先級不一樣的情況，有明顯的差別。

getName()

比較簡單，獲取線程的名稱。

join()和join(long millis)

jion方法的作用是等待線程執行完成，join(long millis)可以設置最長等待時間。比如主線程需要等待子線程完成，獲取子線程的結果后才能繼續往下執行，這時候就可以使用join方法

Thread t1 = new Thread(new Runnable() {
            @Override
            public  void  run() {
                    long t = System.currentTimeMillis();
                    System.out.println(Thread.currentThread().getName()+" start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+" t1 end "+(System.currentTimeMillis()-t));
                }
        });
        t1.start();
        t1.join();
        System.out.println("等待t1執行完，再執行");

執行結果：

Thread-0 start
Thread-0 t1 end 1001
等待t1執行完，再執行

GPU云服務器云服務器 thread多線程 java多線程并發實例 java多線程高并發實例多線程實例

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/70679.html

Java 多線程編程基礎——Thread 類

摘要：程序執行時，至少會有一個線程在運行，這個運行的線程被稱為主線程。程序的終止是指除守護線程以外的線程全部終止。多線程程序由多個線程組成的程序稱為多線程程序。線程休眠期間可以被中斷，中斷將會拋出異常。線程我們在閱讀程序時，表面看來是在跟蹤程序的處理流程，實際上跟蹤的是線程的執行。單線程程序在單線程程序中，在某個時間點執行的處理只有一個。 Java 程序執行時，至少會有一個線程在運行...

zhoutk 2019-08-16 13:32 評論0 收藏0
Java多線程基礎（一）——線程與鎖

摘要：一線程的基本概念單線程簡單的說，單線程就是進程中只有一個線程。多線程由一個以上線程組成的程序稱為多線程程序。當線程調用完方法進入后會自動釋放鎖，線程獲得鎖。一、線程的基本概念 1.1 單線程簡單的說，單線程就是進程中只有一個線程。單線程在程序執行時，所走的程序路徑按照連續順序排下來，前面的必須處理好，后面的才會執行。 Java示例： public class SingleThrea...

WelliJhon 2019-08-16 12:40 評論0 收藏0
Java多線程學習（六）Lock鎖的使用

摘要：返回與此鎖相關聯的給定條件等待的線程數的估計。查詢是否有線程正在等待獲取此鎖。為公平鎖，為非公平鎖線程運行了獲得鎖定運行結果公平鎖的運行結果是有序的。系列文章傳送門: Java多線程學習（一）Java多線程入門 Java多線程學習（二）synchronized關鍵字（1） java多線程學習（二）synchronized關鍵字（2） Java多線程學習（三）volatile關鍵字 ...

Caicloud 2019-08-15 15:30 評論0 收藏0
Java中如何實現多線程

摘要：這種方式實現多線程很簡單，通過自己的類直接，并復寫方法，就可以啟動新線程并執行自己定義的方法。 JAVA多線程實現方式主要有兩種：繼承Thread類、實現Runnable接口。 1、繼承Thread類實現多線程繼承Thread類的方法盡管被我列為一種多線程實現方式，但Thread本質上也是實現了Runnable接口的一個實例，它代表一個線程的實例，并且，啟動線程的唯一方法就是通過...

Flands 2019-08-15 12:29 評論0 收藏0
(二)線程的應用及挑戰

摘要：上下文切換會影響到線程的執行速度，對于系統來說意味著會消耗大量的時間減少上下文切換的方式無鎖并發編程，在多線程競爭鎖時，會導致大量的上下文切換。線程在中的使用在中實現多線程的方式比較簡單，因為中提供了非常方便的來實現多線程。文章簡介上一篇文章我們了解了進程和線程的發展歷史、線程的生命周期、線程的優勢和使用場景，這一篇，我們從Java層面更進一步了解線程的使用內容導航并發編程的...

hqman 2019-08-16 13:55 評論0 收藏0
Java synchronized 多線程同步問題詳解

摘要：同步代碼塊二類，鎖是小括號中的類對象對象。因為對于同一個實例對象，各線程之間訪問其中的同步方法是互斥的。優化同步代碼塊的方式有，減少同步區域或減小鎖的范圍。版權聲明：本文由吳仙杰創作整理，轉載請注明出處：https://segmentfault.com/a/1190000009225706 1. 引言在 Java 多線程編程中，我們常需要考慮線程安全問題，其中關鍵字 synchro...

Eidesen 2019-08-16 10:31 評論0 收藏0