用Array實作queue。
#ifndef QUEUE_H
#define QUEUE_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
template<typename T>
class Queue{
public:
Queue():capacity(100){
this->head = 0;
this->tail = 0;
this->size = 0;
this->array = new T[capacity];
}
Queue(int c){
this->head = 0;
this->tail = 0;
this->size = 0;
this ...一些常出現的sorting演算法。有些雖然效率很差，不過面試還滿常問的。
Bubble sort，把目前在最左邊的值一直往右邊推。
#define SWAP(x,y) int t;t = x;x = y;y = t;
int main(int argc, char const* argv[])
{
int size = 10;
int ary[10] = {1,3,5,6,2,2,7,1,10,0};
for(int i = 0;i<size-1;i++){
bool ...加入template的實作。 Stack.h
//ignore header files
#ifndef STACK_H
#define STACK_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
template<typename T>
class Stack{
public:
Stack(){
this->size = 0;
this->capacity = 100;
this->array = new T[capacity];
}
Stack(int c){
this->size = 0;
this->capacity = c;
this->array = new T ...呼叫 interrupt 方法後，可以中斷掉執行緒。有下面其中一種結果：
若執行緒是中斷狀態，就丟出 InterruptedException，可以像下面這樣寫。
if(Thread.interrupted()){
throw new InterruptedException();
}
Thread.interrupted 方法會檢查 Thread.currentThread() 的中斷狀態。也就是說，上面的 if 敘述無論寫在哪個類別的哪個方法，都是檢查執行 if 敘述的執行緒的中斷狀態。
呼叫 Thread.interrupted 方法後，執行緒就不再是中斷狀態了 ...
講到多執行緒時，我們常常在講concurrent(並行)與parallel(平行)，在單核的情況下，只會出現concurrent，因為concurrent表示的是一段時間只會有一個執行緒在動作;但是在雙核以上的情況下，則會出現parallel的情形，表示同一段時間可能會有多個執行緒在動作。
一般來說，在java中可以透過兩種方式建立thread。
繼承Thread類別，建立PrintThread.java
public class PrintThread extends Thread {
private String message;
public PrintThread(String message) {
this.message = message;
}
public void run() {
for (int i = 0; i < 10000; i++) {
System.out.print(message);
}
}
}
Main.java
public ...對每個命令或請求，配置一個執行緒，由這個執行緒執行工作，這就是 Thread-Per-Message Pattern。
在範例程式中，Main 類別會委託 Host 類別顯示文字。Host 類別會啟動一個執行緒，來處理這項委託的工作。啟動的執行緒，會使用 Helper 類別實際進行顯示動作。 無論 Helper 類別的 handle 方法多花時間，Main 類別的 request 方法都不會等待 handle 方法執行完畢，而會馬上離開。
Client 對 Host 送出請求。Client 並不知道 Host 會如何實現這個請求。例如 Main 類別。
當 Host 收到 Client 的請求，會建立新的執行緒並啟動它 ...
如果現在不需要做這個動作，就直接return，Balking Pattern一般來說不會進入wait set，而是直接放棄不做。
換句話說，不一定要執行。
現在來寫一個在文書處理器上面經常提供的自動儲存功能
ServerThread會不斷地去儲存資料，而ClientThread則會不斷地修改資料並且儲存資料。
當發現資料已經有儲存的時候，就不重複儲存，直接離開。
表示資料的類別，Data.java
import java.io.IOException;
import java.io.FileWriter;
import java.io.Writer;
public class Data {
private final String filename; // 儲存時的檔名
private String content; // 資料的內容
private boolean changed; // 修改後的內容還沒儲存的話，值為true
public Data(String ...所謂的死結，是指兩個執行緒分別取得了鎖定，互相等待另外一個執行緒解除鎖定的現象，發生死結的時候，哪個執行緒都無法繼續執行下去，這時候程式就會不斷等待。
假設有兩個人(Alice and Boddy)在用餐，餐具只有兩個，分別是spoon以及fork，Alice的習慣是左手拿spoon，接著右手拿fork才會開始用餐;Boddy的習慣是左手拿spoon，接著右手拿fork之後才開始用餐。 現在寫一個程式去模擬整個過程，一個不小心可能會出現一個情況：Alice左手拿了spoon，等待fork，但Boddy左手已經拿了fork，等待spoon，這樣互相等待共享資源的情況，就會產生deadlock。
以下是會產生deadlock的程式。
建立shared resource，如下的Tool.java
public class Tool {
private final String name;
public Tool(String name) {
this.name = name;
}
public String toString() {
return "[ " + name + " ]";
}
}
Main ...
當按下按鈕時，會產生 java.awt.event.ActionEvent 這個類別的實體，移動滑鼠的時候，會產生 java.awt.event.MouseEvent 的類別實體。這些實體放在 Swing 的 event queue 中。
如果提到 Worker Thread 的話，那麼產生的 event 可以對應到 Request，event queue 就是 Channel，而 Client 就是對應到管理滑鼠及鍵盤等事件來源的部份。event-dispatching thread 就是 worker。
event-dispatching thread 會從 event queue 中取出一個 event，並執行這個 event ...
假設有一個執行起來需要花一些時間的方法，我們就不要等待執行結果出來了，而取得一張替代的提貨卷。因為取得提貨卷不需要花時間，這時這個提貨卷就是 Future 參與者。
取得 Future 的執行緒，會在事後再去取得執行結果。如果已經有結果了，就可以馬上到資料。如果執行結果還沒好，則繼續等到執行結果出現為止。
與 Thread-Per-Message Pattern 比較的話，送出請求的方法是有回傳值的，而回傳值剛好就是 Future 參與者。
程式範例：
Client 會向 Host 發出 Request。Client 會馬上得到 VirtualData (Future)，作為這個 Request 的結果。例如 Main 類別。
Host 會建立新的執行緒，開始建立 RealData。另外，會對 Client 回傳 ...