浪費了“黃金五年”的Java程式設計師，還有救嗎？ >>>   

suspend、resume、stop

• suspend：執行緒掛起：阻塞,但是不會釋放持有資源，包含鎖資源(過期)
• resume：恢復執行緒執行：掛起-->就緒
• stop: 暴力終止執行緒

終止執行緒優雅做法，設定執行緒執行的開關

volatile 保證資料的可見性，執行緒執行時每次都會從公共記憶體載入on資料

Thread.currentThread().isInterrupted()： 判斷執行緒是否被中斷：interrupted()

private static class Runner implements Runnable {
    private long i;
    private volatile boolean on = true;
    [@Override](https://my.oschina.net/u/1162528)
    public void run() {
        while (on && !Thread.currentThread().isInterrupted()){
            i++;
        }
        System.out.println("Count i = " + i);
    }
    public void cancel() {
        on = false;
    }
}
 

缺點：

1. 獨佔，suspend方法是執行緒作用的公共同步物件的鎖不會被釋放，造成其他執行緒無法訪問公共同步物件

2. 資料不一致：例如物件屬性賦值時中間掛起執行執行緒，導致整個執行緒的關聯的物件屬性賦值執行過程不完整，造成資料不一致的情況

• 測試程式碼

package com.zhiwei.thread;

public class ThreadSuspend {

	@SuppressWarnings("deprecation")
	public static void main(String[] args) throws InterruptedException {
		
		SuspendThread suspendThread = new SuspendThread();
		suspendThread.start();
		
		Thread.sleep(5000);
		
		System.out.println("執行緒第1次被掛起-------------------");
		suspendThread.suspend();
		
		System.out.println("執行緒第1次恢復執行-------------------");
		suspendThread.resume();
		
		Thread.sleep(5000);
		
		System.out.println("執行緒第2次被掛起-------------------");
		suspendThread.suspend();
	}
	
}

class SuspendThread extends Thread{
	
	private long i = 0;
	
	public long get(){
		return i;
	}
	
	public void set(long i){
		this.i = i;
	}
	
	@Override
	public void run() {
		while(true){
			System.out.println("i:"+i);
			try {
				Thread.sleep(1000);
				i++;
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}
 

效果：

---

wait、notify

wait:當前訪問物件的執行緒被阻塞，並且放棄之前擁有的資源，直到被notify/notifyAll方法喚醒，在原來中斷的地方繼續執行

擴充套件：執行緒從原來中斷的地方繼續執行的原因：作業系統是統一管理所有的軟硬體資源的軟體，程序是程式分配資源的單位，執行緒則是程序進行資源進一步劃分的最小的分配資源單位，當執行緒或程序被中斷的時候，作業系統會自動將當前執行緒/程序的狀態存入執行緒控制塊(TCB)和程序控制塊(PCB)，然後阻塞當前執行的執行緒/程序，當執行緒/程序達到執行的條件，作業系統會從之前儲存的TCB/PCB中讀取資訊，恢復中斷前的狀態，所以執行緒/程序就成從中斷的地方繼續執行

notify: 喚醒訪問目標物件的1個阻塞執行緒，執行緒進入就緒狀態，分配CPU資源即可執行

注意：如果存在多個執行緒訪問同一個物件，notify喚醒的執行緒是隨機的，notifyAll可以喚醒所有的阻塞執行緒

測試案例：

package com.zhiwei.thread;

public class WaitAndNotify {
	
   private static Object object = new Object();
   
	public static void main(String[] args) throws InterruptedException{
	  threadWait tw = new threadWait();
      threadNotify tn = new threadNotify();
      Thread th1 = new Thread(tw);
      Thread th2 = new Thread(tn);
      th1.start();
      th2.start();
	}
	
	
	private static class threadWait implements Runnable{
		@Override
		public void run() {
			synchronized (object) { 
				try {
					System.out.println(Thread.currentThread().getName() + ":object物件鎖釋放前！");
					object.wait();  
			System.out.println(Thread.currentThread().getName() + "：object物件鎖釋放後！"); 
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	private static class threadNotify implements Runnable{

		@Override
		public void run() {
			synchronized (object) {
				try {
					System.out.println(Thread.currentThread().getName()+"：object物件鎖獲取前！");
					object.notify(); 
					System.out.println(Thread.currentThread().getName()+":object物件鎖獲取後！(JVM決定喚醒另外執行緒)");
				} catch (Exception e) {
					e.printStackTrace();
				}
			}		
		}
	}
}

結果：

Thread-0: object物件鎖釋放前！
Thread-1：object物件鎖獲取前！
Thread-1: object物件鎖獲取後！(JVM決定喚醒另外執行緒)
Thread-0：object物件鎖釋放後！

分析：

1. 執行緒threadWait執行時synchronized (object)的原因，執行緒threadNotify執行緒阻塞，等待threadWait釋放物件鎖才可以執行

2. 當threadWait執行到 object.wait()時，threadWait執行緒被手動阻塞中斷，釋放物件鎖，因此控制檯只會輸出之前的

“Thread-0:object物件鎖釋放前！”

3. 因threadWait釋放物件鎖，執行緒threadNotify執行，當執行object.notify(); 時，因object只有1個阻塞執行緒，因此threadWait執行緒被喚醒，但是由於threadNotify還在執行同步程式碼塊，因此執行緒threadWait進入阻塞狀態，當執行緒threadNotify執行完成同步程式碼塊，控制檯輸出

"Thread-1：object物件鎖獲取前！
Thread-1:object物件鎖獲取後！(JVM決定喚醒另外執行緒)"

4. threadNotify持有的object物件鎖釋放，threadWait獲取物件鎖繼續執行，控制檯輸出

"Thread-0：object物件鎖釋放後！"

---

await、signal

await和signal類似wait和notify的關係，await會阻塞當前執行緒，直到接收到signal後喚醒繼續執行，這也是執行緒的一種通訊機制

需求：多執行緒交替列印字元

測試程式碼

package com.zhiwei.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TheadAwait {

	public boolean flag = true;
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();

	public void get() {
		try {
			Thread.sleep(5000);
			lock.lock();
			while (!flag) {
				condition.await();
			}
			System.out.println(Thread.currentThread().getName()+":-----------------");
			flag = !flag;
			condition.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void put() {
		try {
			Thread.sleep(5000);
			lock.lock();
			while (flag) {
				condition.await();
			}
			System.out.println(Thread.currentThread().getName()+":*****************");
			flag = !flag;
			condition.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public static void main(String[] args) {

		TheadAwait alternatelyPrint = new TheadAwait();
		while (true) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					alternatelyPrint.get();
				}
			}).start();

			new Thread(new Runnable() {
				@Override
				public void run() {
					alternatelyPrint.put();
				}
			}).start();
		}
	}
}

效果：

---

Callable、Future

Callable: 可理解成執行緒執行的具體任務，但具有返回值 Future：Callable執行的返回值

作用：線上程執行的過程中可獲取到執行緒執行的狀態，例如非同步的情況，可通過執行緒執行後的狀態進行響應的控制，而不至於因為執行緒執行的不確定性造成不可控

注意：future.get() 會造成執行緒阻塞，一致到有返回值才進行下一步操作

• 測試程式碼

package com.zhiwei.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * callable物件是具有返回值的物件，並且將結果返回給Future物件：
 * completService可以一次執行一組callable獨享方法,並返回最早的結果
 */
public class CallableAndFuture {

	public static void main(String[] args) throws Exception {

		ExecutorService threadPool = Executors.newSingleThreadExecutor();
		Future<String> future = threadPool.submit(new Callable<String>() {
			public String call() throws Exception {
				Thread.sleep(5000);
				return "hello Java World!";
			}
		});
		
		System.out.println("5s執行緒返回結果：" + future.get());
		threadPool.shutdown();
	}
}

效果：5s後

相關推薦