本來打算簡單的說一說java執行緒就算的，無奈執行緒實在是博大精深，一篇文章連基礎都說不完，所以又寫了個下篇來說一說執行緒的問題。上一節說了說執行緒的基本概念以及其基本的使用方法，也說明了執行緒存在的問題，這篇文章主要就執行緒會出現的問題來做出解決辦法。

同步

上一節已經說過執行緒的非同步有時候會出現問題，所以為了解決有時候會出現的問題就要用同步來解決。事實上只要有多個執行緒共享資源，都必須要考慮同步。這些執行緒可能是Thread的繼承類也可能實現了Runnable介面，也可能是完全不同的類的例項。關鍵在於這些執行緒所共享的資源，而不是這些執行緒是哪個類。

synchronized關鍵字

/**
 * 
 
@author Aaron
 * @建立日期：2017年8月31日下午11:01:33
 * @修改日期
 */
public classSynchronizedDemoimplementsRunnable{

	@Override
	publicvoidrun(){
		FileInputStream fis;
		try {
			fis = new FileInputStream("D:/test.txt");
			MessageDigest sha = MessageDigest.getInstance("SHA-256");
			DigestInputStream din = new DigestInputStream(fis, sha);
			while
 
 (din.read() != -1) {//讀取整個檔案
				byte[] digest = sha.digest();
				System.out.println(fis+":");
				System.out.println(DatatypeConverter.printHexBinary(digest));
				System.out.println();
				din.close();
			}

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch
 
 (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	publicstaticvoidmain(String[] args){
		for (int i = 0; i < 4; i++) {
			SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
			Thread thread = new Thread(synchronizedDemo);
			thread.start();
		}
		
	}

}

可以看出來程式並沒有按照順序輸出，這就是執行緒非同步造成的結果，為了讓程式順序輸出得到我們想要的結果我們可以使用synchronize來操作。使用synchronize把輸出的程式碼包圍起來就會對system.out同步了。

synchronized (System.out) {
					System.out.println(fis+":");
					System.out.println(DatatypeConverter.printHexBinary(digest));
					System.out.println();
					din.close();
				}

這個時候我們可以看到就是順序輸出的結果了。一旦執行緒開始列印這些值，所有其他執行緒在列印它們的值之前都必須停止來等待這個執行緒結束。同步要求同一物件的所有程式碼必須連續的執行，而不能並行執行（如果其他的類中的其他程式碼塊也對此物件執行了同步，那麼這個物件也是不能並行執行的）。Java沒有提供任何房啊來阻止其他執行緒使用共享資源，它只能防止對同一物件的其他執行緒使用這個資源。只有多個執行緒共享資源的時候才會考慮同步。

我們不僅可以對物件使用同步，還可以對方法使用同步。但是使用同步並不是一一勞永逸的方法，因為這會是VM的效能下降，並且增加了死鎖的可能性。

死鎖

假如A先生和B先生需要分別借兩本一樣的書來作為參考資料來寫論文，但是A先生先寄走了A書，B先生又借走了B書，這樣兩個人就都寫不成論文了。所以就造成了死鎖。

/**
 * @author Aaron
 * @建立日期：2017年8月31日下午11:01:33
 * @修改日期
 */
public abstract classSynchronizedDemoimplementsRunnable{

	publicstaticvoidmain(String[] args)throws InterruptedException {
		Object obj1 = new Object();
		Object obj2 = new Object();
		Object obj3 = new Object();

		Thread t1 = new Thread(new SyncThread(obj1, obj2), "t1");
		Thread t2 = new Thread(new SyncThread(obj2, obj3), "t2");
		Thread t3 = new Thread(new SyncThread(obj3, obj1), "t3");

		t1.start();
		Thread.sleep(5000);
		t2.start();
		Thread.sleep(5000);
		t3.start();

	}

}

classSyncThreadimplementsRunnable{
	private Object obj1;
	private Object obj2;

	publicSyncThread(Object o1, Object o2){
		this.obj1 = o1;
		this.obj2 = o2;
	}

	@Override
	publicvoidrun(){
		String name = Thread.currentThread().getName();
		System.out.println(name + " acquiring lock on " + obj1);
		synchronized (obj1) {
			System.out.println(name + " acquired lock on " + obj1);
			work();
			System.out.println(name + " acquiring lock on " + obj2);
			synchronized (obj2) {
				System.out.println(name + " acquired lock on " + obj2);
				work();
			}
			System.out.println(name + " released lock on " + obj2);
		}
		System.out.println(name + " released lock on " + obj1);
		System.out.println(name + " finished execution.");
	}

	privatevoidwork(){
		try {
			Thread.sleep(30000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

以上就是一個非常經典的死鎖的例子：

從結果裡就可以看出來程式一直在執行無法停止。

多個執行緒切換執行

public static void main(String[] args) {
Print print = new Print();
Number number = new Number(print);
Letter letter = new Letter(print);
Thread thread = new Thread(number);
Thread thread2 = new Thread(letter);
thread.start();
thread2.start();
}
private Print print;

/**
 * 帶引數的構造方法傳入 print物件 確保兩個執行緒類操作的是同一個物件
 * 
 * @param print
 */
public Number(Print print) {
    super();
    this.print = print;
}

@Override
public void run() {
    if (print.getTemp()) {//如果符合條件就往下執行
        synchronized (print) {//該物件獲得鎖
            for (int i = 1; i <= 52; i++) {
                System.out.println(i);
                if (i % 2 == 0) {
                    try {
                        print.setTemp(false);//首先把標誌更改
                        print.notifyAll();//喚醒其他所有正在等待的執行緒
                        print.wait();//並把此執行緒處於等待狀態
                        print.notify();//喚醒此執行緒，防止程式執行到最後仍處於未停止狀態
                    } catch (InterruptedException e1) {
                        e1.printStackTrace();
                    }
                }

            }
        }
    }
}
private Print print;

public Letter(Print print) {
    super();
    this.print = print;
}

@Override
public void run() {
    if (!print.getTemp()) {
        synchronized (print) {
            for (int i = 65; i <= 90; i++) {
                System.out.println((char) i);
                try {
                    print.setTemp(true);
                    print.notifyAll();
                    print.wait();
                    print.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
private boolean temp = true;
public boolean getTemp() {
    return temp;
}

public void setTemp(boolean temp) {
    this.temp = temp;
}

避免死鎖

有很多方針可供我們使用來避免死鎖的局面。

• 避免巢狀封鎖：這是死鎖最主要的原因的，如果你已經有一個資源了就要避免封鎖另一個資源。如果你執行時只有一個物件封鎖，那是幾乎不可能出現一個死鎖局面的。例如，這裡是另一個執行中沒有巢狀封鎖的run()方法，而且程式執行沒有死鎖局面，執行得很成功。

public void run() {
    String name = Thread.currentThread().getName();
    System.out.println(name + " acquiring lock on " + obj1);
    synchronized (obj1) {
        System.out.println(name + " acquired lock on " + obj1);
        work();
    }
    System.out.println(name + " released lock on " + obj1);
    System.out.println(name + " acquiring lock on " + obj2);
    synchronized (obj2) {
        System.out.println(name + " acquired lock on " + obj2);
        work();
    }
    System.out.println(name + " released lock on " + obj2);
 
    System.out.println(name + " finished execution.");
}

• 只對有請求的進行封鎖：你應當只想你要執行的資源獲取封鎖，比如在上述程式中我在封鎖的完全的物件資源。但是如果我們只對它所屬領域中的一個感興趣，那我們應當封鎖住那個特殊的領域而並非完全的物件。
• 避免無限期的等待：如果兩個執行緒正在等待物件結束，無限期的使用執行緒加入，如果你的執行緒必須要等待另一個執行緒的結束，若是等待程序的結束加入最好準備最長時間。

執行緒排程

當多個執行緒執行的時候必須要考慮執行緒的執行順序的問題，因為既要避免死鎖又要避免飢餓等待。

優先順序

在Java中不是所有的執行緒都是均等的，每個執行緒都有一個優先順序，從0——10不等，0是最低階，10是最高階。如果不對執行緒指定優先順序就會預設5。要注意的事不是所有的作業系統都支持者11個優先順序，Windows只有7個優先順序，並且1和2,3和4,6和7,8和9會做同樣的處理，也就是說優先順序9的執行緒並不會搶佔優先順序8的執行緒。執行緒的優先順序可以通過setPriority來改變

publicstaticvoidmain(String[] args)throws InterruptedException {
		ListCallbackDigest lad = new ListCallbackDigest(fileName);
		lad.add(this);
		Thread thread = new Thread(lad);
		thread.setPriority(9);
		thread.start();
	}

不過，一般情況加不要使用太高優先順序，因為可能會造成其他執行緒飢餓狀態。

搶佔

執行緒排程器主要有兩種：搶佔式和協作式。搶佔式執行緒排程器確定一個執行緒正常的輪到其CPU時間的時候回暫停這個執行緒，協作式將CPU控制權交給其他執行緒的時候會等待正在執行的執行緒自己暫停。

放棄

yield()方法將通知虛擬機器如果有一個執行緒在等待執行那麼就可以執行，當前執行緒放棄執行。

休眠

sleep()

interrrupt()

連線執行緒

join()

等待、通知

wait()

notify()

notifyAll()

結束

執行緒以合理的方法結束，執行緒將撤銷，其他執行緒接管CPU。

執行緒池

這裡我們只簡單的說一下執行緒池的問題。之前就已經瞭解到向一個程式中新增多個執行緒會極大的提升效能，尤其是I/O受限的程式。不過，執行緒也是需要開銷的，如果一個程式中有數百個執行緒，java虛擬機器會做大量的工作，就算是執行緒很快就會結束，但是對虛擬機器而言也會加重垃圾回收器等的負擔，為了減輕CPU的開銷減輕虛擬機器的壓力我們可以使用java.util.concurrent中的Excutors類，輕鬆的建立執行緒池。

**
 * @author Aaron
 * @建立日期：2017年9月5日下午5:09:37
 * @修改日期
 */
public classExcutorsDemoimplementsRunnable{
	private File inputs;

	publicExcutorsDemo(File inputs){
		this.inputs = inputs;
	}

	@Override
	publicvoidrun(){
		// 不壓縮已經壓縮的檔案
		if (!inputs.getName().endsWith(".gz")) {
			File outputs = new File(inputs.getParent(), inputs.getName()
					+ ".gz");
			if (!outputs.exists()) {
				// 不覆蓋已經存在的檔案
				try (InputStream is = new BufferedInputStream(
						new FileInputStream(inputs));
						OutputStream os = new BufferedOutputStream(
								new GZIPOutputStream(new FileOutputStream(
										outputs)));) {
					int b;
					while ((b = is.read()) != -1) {
						os.write(b);
						os.flush();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}

			}
		}

	}

	public File getInputs(){
		return inputs;
	}

	publicvoidsetInputs(File inputs){
		this.inputs = inputs;
	}

}

/**
 * @author Aaron
 * @建立日期：2017年9月5日下午5:21:39
 * @修改日期
 */
public class ExcutorsDemoMain {
	public final static int THREAD_COUNT = 4;

	public static void main(String[] args) {
		ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT);
		for (String filename : args) {
			File file = new File(filename);
			if (file.exists()) {
				if (file.isDirectory()) {
					File[] files = file.listFiles();
					for (int i = 0; i < files.length; i++) {
						if (!files[i].isDirectory()) {// 不遞迴處理目錄
							Runnable task = new ExcutorsDemo(files[i]);
							pool.submit(task);
						}
					}
				} else {
					Runnable task = new ExcutorsDemo(file);
					pool.submit(task);
				}
			}
		}
		pool.shutdown();
	}
}

我們使用GZIPOutputStream過濾流來對當前目錄的每一個檔案進行壓縮，一方面這是一個大量的I/O操作，另一方面資料壓縮是一個CPU密集度很高的操作，所以我們不能用太多執行緒，這是使用執行緒池的大好機會，客戶端執行緒將壓縮檔案，主程式告訴執行緒壓縮什麼檔案，在這裡主程式會遠遠快於執行緒，所以我們需要填充執行緒池，然後啟動執行緒池的中執行緒。主程式構造 了一個執行緒池並填充了4個執行緒，以迭代的方式列出所有的檔案和目錄，這些檔案以及這些目錄中的檔案會用來構建ExcutorsDemo，然後交到執行緒池，最後由著4個執行緒之一處理。一旦將所有的檔案增加到這個執行緒池，就可以呼叫pool.shutDown，這個方法不會終止等待的工作，他只是通知執行緒池在沒有更多的任務增加到內部佇列，而且一旦完成所有的等待的工作就應當關閉。

這裡我給出一個操作I/O經典不算複雜的例子：

public class Test {
    int a = 0;
    static File startPath = null;
    static File endPath = null;
    public static void main(String[] args) throws IOException {
    Scanner input = new Scanner(System.in);
    System.out.println("請輸入您要複製的原目錄：(完整目錄)");
    startPath = new File(input.next());
    System.out.println("請輸入您要複製的目標目錄：(完整目錄)");
    endPath = new File(input.next());
    Test2016510 test2016510 = new Test2016510();
    test2016510.copy(startPath, endPath);
    System.out.println("複製完成");
}
@SuppressWarnings("unused")
public void copy(File startFile, File endFile) throws IOException {

    File startFilePath = startFile;
    File endFilePath = endFile;

    File[] startfilePaths = startFilePath.listFiles();
    if (startFile.exists()) {
        for (File file : startfilePaths) {

            if (file.isDirectory()) {
                if (file != null) {
                    String ss = file.toString().substring(3,
                            file.toString().length());
                    File newFile = new File(endFilePath.toString() + "\\"
                            + ss);
                    newFile.mkdirs();
                    this.copy(file, newFile);
                } else {
                    String ss = file.toString().substring(3,
                            file.toString().length());
                    File newFile = new File(endFilePath.toString() + "\\"
                            + ss);
                    newFile.mkdirs();
                }
            } else if (file.isFile()) {
                String ss = file.getPath().substring(3,
                        file.toString().length());
                File newFile = new File(this.endPath + "\\" + ss);
                String ssss = file.getParent().substring(3);
                File parentFile = new File(this.endPath + "\\" + ssss);
                if (!parentFile.exists()) {
                    parentFile.mkdirs();
                    FileInputStream fis = new FileInputStream(file);
                    BufferedInputStream bis = new BufferedInputStream(fis);

                    FileOutputStream fos = new FileOutputStream(newFile);
                    BufferedOutputStream bos = new BufferedOutputStream(fos);

                    byte[] buff = new byte[1024];
                    int temp = 0;
                    while ((temp = bis.read(buff)) != -1) {
                        bos.write(buff, 0, temp);
                        bos.flush();
                    }
                    bos.close();
                    fos.close();
                    bis.close();
                    fis.close();
                } else {
                    FileInputStream fis = new FileInputStream(file);
                    BufferedInputStream bis = new BufferedInputStream(fis);

                    FileOutputStream fos = new FileOutputStream(newFile);
                    BufferedOutputStream bos = new BufferedOutputStream(fos);

                    byte[] buff = new byte[1024];
                    int temp = 0;
                    while ((temp = bis.read(buff)) != -1) {
                        bos.write(buff, 0, temp);
                        bos.flush();
                    }
                    bos.close();
                    fos.close();
                    bis.close();
                    fis.close();
                }

            }
        }
    } else {
        System.out.println("您指定的檔案不存在，程式結束。");
    }
}

這個列子使用位元組流完整的複製資料夾以及檔案裡面的檔案，對於理解I/O會有幫助。當然更復雜的運算，我們還可以使用多執行緒甚至執行緒池來複制完整的檔案以及資料夾，就有點類似於某雷了。