java多執行緒的基礎知識總結（附程式碼）

這篇文章帶給大家的內容是關於java多執行緒的基礎知識總結（附程式碼），有一定的參考價值，有需要的朋友可以參考一下，希望對你有幫助。

Java 主執行緒名稱

我們啟動的一個程式可以理解為一個行程, 一個行程包含一個主執行緒, 執行緒可以理解為一個子任務. Java中可以透過下面程式碼來取得預設的主執行緒名.

System.out.println(Thread.currentThread().getName());

運行結果為 main, 這是執行緒的名字並不是 main 方法, 透過此執行緒來執行 main 方法而已.

兩種方式建立執行緒

1.繼承Thread 類別

public class Thread1 extends Thread {
    @Override
    public void run() {
        System.out.println("qwe");
    }
}

2.實作Runnable 介面

public class Thread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("asd");
    }
}

Thread 實作 Runnable 介面. 且多執行緒執行時, 程式碼的執行順序與呼叫順序是無關的. 另外如果多次呼叫 start方法則會拋出 java.lang.IllegalThreadStateException

currentThread 方法

#傳回目前程式碼正在被哪個執行緒呼叫.

public class Thread1 extends Thread {

    public Thread1() {
        System.out.println("构造方法的打印：" + Thread.currentThread().getName());
    }

    @Override
    public void run() {
        System.out.println("run 方法的打印：" + Thread.currentThread().getName());
    }
}

Thread1 thread1 = new Thread1();
thread1.start();

isAlive 方法

判斷目前執行緒是否處於活動狀態.

public class Thread1 extends Thread {
    @Override
    public void run() {
        System.out.println("run 方法的打印 Thread.currentThread().isAlive() == " + Thread.currentThread().isAlive());
        System.out.println("run 方法的打印 this.isAlive() == " + this.isAlive());
        System.out.println("run 方法的打印 Thread.currentThread().isAlive() == this.isAlive() == " + (Thread.currentThread() == this ? "true" : "false"));
    }
}

Thread1 thread1 = new Thread1();

System.out.println("begin == " + thread1.isAlive());
thread1.start();
Thread.sleep(1000);
System.out.println("end == " + thread1.isAlive());

執行結果如下

begin == false
run 方法的打印 Thread.currentThread().isAlive() == true
run 方法的打印 this.isAlive() == true
run 方法的打印 Thread.currentThread() == this == true
end == false

thread1 在1秒之後執行完成.所以輸出結果為 false. 並且 Thread.currentThread() 和 this 是同一個物件, 可以理解成執行當前 run 方法的線程物件就是我們自己(this).

如果將線程物件以建構參數的方式傳遞給Thread 物件進行 start() 啟動時, 執行結果和前面實例是有差異的. 造成這樣的差異的原因還是來自於 Thread.currentThread() 和 this 的差異.

System.out.println("begin == " + thread1.isAlive());
//thread1.start();
// 如果将线程对象以构造参数的方式传递给 Thread 对象进行 start() 启动
Thread thread = new Thread(thread1);
thread.start();

Thread.sleep(1000);
System.out.println("end == " + thread1.isAlive());

執行結果

begin == false
run 方法的打印 Thread.currentThread().isAlive() == true
run 方法的打印 this.isAlive() == false
run 方法的打印 Thread.currentThread() == this == false
end == false

Thread.currentThread().isAlive() 是 true 的原因是因為, Thread.currentThread() 返回的是 thread 物件, 而我們也是透過此物件來啟動執行緒的, 所以是在活動狀態的, 所以是在活動狀態.

this.isAlive() 是 false 就比較好理解了, 因為我們是透過 thread 物件啟動的執行緒來執行 run 方法的. 所以它是 false. 同時也說明這兩個不是同一個物件.

sleep 方法

在指定的毫秒數內讓目前"正在執行的執行緒" 休眠. "正在執行的執行緒" 只得是Thread.currentThread()返回的線程.

Thread.sleep(1000);

停止線程

停止一個線程意味著在線程處理完任務之前停掉正在做的操作, 也就是放棄當前的操作.

在Java 中有以下3 種方法可以終止正在執行的執行緒:

1. 使用退出標誌, 讓執行緒正常退出, 也就是當run 方法完成後執行緒終止.

2. 使用stop 方法強行終止執行緒, 但是不建議使用這個方法.

3. #使用interrupt 方法中斷執行緒.

停不了的線程

調用interrupt 方法只是當前線程打了一個停止標記, 並不是真正的停止線程.

public class Thread1 extends Thread {
    @Override
    public void run() {

        for(int i = 0; i < 500000; i++) {
            System.out.println(i);
        }
    }
}

Thread1 thread1 = new Thread1();
thread1.start();
Thread.sleep(2000);
thread1.interrupt();

我們兩秒後調用 interrupt 方法, 根據打印結果我們可以看到線程並沒有停止, 而是在執行完500000 此循環後run 方法結束線程停止.

判斷線程是否是停止狀態

我們將線程標記為停止後, 需要在線程內部判斷一下這個線程是否是停止標記, 如果是則停止線程.

兩種判斷方法:

1. Thread.interrupted(); 也可以使用this.interrupted();

2. #this.isInterrupted();

##以下是兩個方法的原始碼:

    public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }
    
    public boolean isInterrupted() {
        return isInterrupted(false);
    }

interrupted() 方法資料靜態方法, 也就是判斷目前執行緒是否已經中斷. isInterrupted() 判斷執行緒是否已經被中斷.

來自官網的

interrupted() 方法重點.線程的中斷狀態由該方法清除. 換句話說, 如果連續兩次調用該方法, 則第二次調用將傳回false (在第一次呼叫已清除了其中斷狀態之後, 且第二次呼叫檢驗完中斷狀態前, 當前執行緒再次中斷的情況除外).

異常停止執行緒

public class Thread1 extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 500000; i++) {
                if (this.isInterrupted()) {
                    System.out.println("线程停止");
                    throw new InterruptedException();
                }

                System.out.println("i = " + i);
            }
        } catch (InterruptedException e) {
            System.out.println("线程通过 catch 停止");
            e.printStackTrace();
        }
    }
}

Thread1 thread1 = new Thread1();
thread1.start();
Thread.sleep(1000);
thread1.interrupt();

輸出結果, 這是最後幾行:

i = 195173
i = 195174
i = 195175
线程停止
线程通过 catch 停止
java.lang.InterruptedException
    at Thread1.run(Thread1.java:9)

當然我們也可以將

throw new InterruptedException(); 換成return. 都是一樣可以結束執行緒的.

在沉睡中停止

如果執行緒呼叫

Thread.sleep() 方法使執行緒進行休眠, 這時我們呼叫thread1.interrupt ()後會拋出. InterruptedException 例外.

java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at Thread1.run(Thread1.java:8)

暴力停止執行緒

暴力停止執行緒可以使用

stop 方法, 但此方法已經過時並不建議使用, 原因如下.

1. 即刻抛出 ThreadDeath 异常, 在线程的run()方法内, 任何一点都有可能抛出ThreadDeath Error, 包括在 catch 或 finally 语句中. 也就是说代码不确定执行到哪一步就会抛出异常.

2. 释放该线程所持有的所有的锁. 这可能会导致数据不一致性.

public class Thread1 extends Thread {

    private String userName = "a";
    private String pwd = "aa";

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public void run() {
        this.userName = "b";
        try {
            Thread.sleep(100000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.pwd = "bb";

    }
}

Thread1 thread1 = new Thread1();
thread1.start();
Thread.sleep(1000);
thread1.stop();

System.out.println(thread1.getUserName() + "     " + thread1.getPwd());

输出结果为:

b     aa

我们在代码中然线程休眠 Thread.sleep(100000); 是为了模拟一些其它业务逻辑处理所用的时间, 在线程处理其它业务的时候, 我们调用 stop 方法来停止线程.

线程是被停止了也执行了 System.out.println(thread1.getUserName() + "     " + thread1.getPwd()); 来帮我们输出结果, 但是 this.pwd = "bb"; 并没有被执行.

所以, 当调用了 stop 方法后, 线程无论执行到哪段代码, 线程就会立即退出, 并且会抛出 ThreadDeath 异常, 而且会释放所有锁, 从而导致数据不一致的情况.

interrupt 相比 stop 方法更可控, 而且可以保持数据一致, 当你的代码逻辑执行完一次, 下一次执行的时候, 才会去判断并退出线程.

如果大家不怎么理解推荐查看 为什么不能使用Thread.stop()方法？ 这篇文章. 下面是另一个比较好的例子.

如果线程当前正持有锁(此线程可以执行代码), stop之后则会释放该锁. 由于此错误可能出现在很多地方, 那么这就让编程人员防不胜防, 极易造成对象状态的不一致. 例如, 对象 obj 中存放着一个范围值: 最小值low, 最大值high, 且low不得大于high, 这种关系由锁lock保护, 以避免并发时产生竞态条件而导致该关系失效.

假设当前low值是5, high值是10, 当线程t获取lock后, 将low值更新为了15, 此时被stop了, 真是糟糕, 如果没有捕获住stop导致的Error, low的值就为15, high还是10, 这导致它们之间的小于关系得不到保证, 也就是对象状态被破坏了！

如果在给low赋值的时候catch住stop导致的Error则可能使后面high变量的赋值继续, 但是谁也不知道Error会在哪条语句抛出, 如果对象状态之间的关系更复杂呢？这种方式几乎是无法维护的, 太复杂了！如果是中断操作, 它决计不会在执行low赋值的时候抛出错误, 这样程序对于对象状态一致性就是可控的.

suspend 与 resume 方法

用来暂停和恢复线程.

独占

public class PrintObject {
    synchronized public void printString(){
        System.out.println("begin");
        if(Thread.currentThread().getName().equals("a")){
            System.out.println("线程 a 被中断");
            Thread.currentThread().suspend();
        }
        if(Thread.currentThread().getName().equals("b")){
            System.out.println("线程 b 运行");
        }
        System.out.println("end");
    }
}

try{
    PrintObject  pb = new PrintObject();
    Thread thread1 = new Thread(pb::printString);
    thread1.setName("a");
    thread1.start();
    thread1.sleep(1000);

    Thread thread2 = new Thread(pb::printString);
    thread2.setName("b");
    thread2.start();
}catch(InterruptedException e){ }

输出结果:

begin
线程 a 被中断

当调用 Thread.currentThread().suspend(); 方法来暂停线程时, 锁并不会被释放, 所以造成了同步对象的独占.

以上是java多執行緒的基礎知識總結（附程式碼）的詳細內容。更多資訊請關注PHP中文網其他相關文章！