高併發Java 二多線程基

1. 什麼是線程

線程是進程內的執行單元

某個進程當中都有若干個線程。

線程是進程內的執行單元。

使用線程的原因是，進程的切換是非常重量級的操作，非常消耗資源。如果使用多進程，那麼併發數相對來說不會很高。而線程是更細小的調度單元，更加輕量級，所以線程會較爲廣泛的用於併發設計。

在Java當中線程的概念和操作系統級別線程的概念是類似的。事實上，Jvm將會把Java中的線程映射到操作系統的線程區。

2. 線程的基本操作

2.1 線程狀態圖

上圖是Java中線程的基本操作。

當new出一個線程時，其實線程並沒有工作。它只是生成了一個實體，當你調用這個實例的start方法時，線程才真正地被啓動。啓動後到Runnable狀態，Runnable表示該線程的資源等等已經被準備好，已經可以執行了，但是並不表示一定在執行狀態，由於時間片輪轉，該線程也可能此時並沒有在執行。對於我們來說，該線程可以認爲已經被執行了，但是是否真實執行，還得看物理cpu的調度。當線程任務執行結束後，線程就到了Terminated狀態。

有時候在線程的執行當中，不可避免的會申請某些鎖或某個對象的監視器，當無法獲取時，這個線程會被阻塞住，會被掛起，到了Blocked狀態。如果這個線程調用了wait方法，它就處於一個Waiting狀態。進入Waiting狀態的線程會等待其他線程給它notify，通知到之後由Waiting狀態又切換到Runnable狀態繼續執行。當然等待狀態有兩種，一種是無限期等待，直到被notify。一直則是有限期等待，比如等待10秒還是沒有被notify，則自動切換到Runnable狀態。

2.2 新建線程

Thread thread = new Thread();
thread.start();

這樣就開啓了一個線程。

有一點需要注意的是

Thread thread = new Thread();
thread.run();

直接調用run方法是無法開啓一個新線程的。

start方法其實是在一個新的操作系統線程上面去調用run方法。換句話說，直接調用run方法而不是調用start方法的話，它並不會開啓新的線程，而是在調用run的當前的線程當中執行你的操作。

Thread thread = new Thread("t1")
{
	@Override
	public void run()
	{
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName());
	}
};
thread.start();

如果調用start，則輸出是t1

Thread thread = new Thread("t1")
{
	@Override
	public void run()
	{
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName());
	}
};
thread.run();

如果是run,則輸出main。（直接調用run其實就是一個普通的函數調用而已，並沒有達到多線程的作用）

run方法的實現有兩種方式

第一種方式，直接覆蓋run方法，就如剛剛代碼中所示，最方便的用一個匿名類就可以實現。

Thread thread = new Thread("t1")
{
	@Override
	public void run()
	{
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName());
	}
};

第二種方式

Thread t1=new Thread(new CreateThread3());

CreateThread3()實現了Runnable接口。

在張孝祥的視頻中，推薦第二種方式，稱其更加面向對象。

2.3 終止線程

Thread.stop() 不推薦使用。它會釋放所有monitor

在源碼中已經明確說明stop方法被Deprecated，在Javadoc中也說明了原因。

原因在於stop方法太過"暴力"了，無論線程執行到哪裏，它將會立即停止掉線程。

當寫線程得到鎖以後開始寫入數據，寫完id = 1，在準備將name = 1時被stop,釋放鎖。讀線程獲得鎖進行讀操作，讀到的id爲1，而name還是0，導致了數據不一致。

最重要的是這種錯誤不會拋出異常，將很難被發現。

2.4 線程中斷

線程中斷有3種方法

public void Thread.interrupt() // 中斷線程 
public boolean Thread.isInterrupted() // 判斷是否被中斷 
public static boolean Thread.interrupted() // 判斷是否被中斷，並清除當前中斷狀態

什麼是線程中斷呢？

如果不瞭解Java的中斷機制，這樣的一種解釋極容易造成誤解，認爲調用了線程的interrupt方法就一定會中斷線程。
其實，Java的中斷是一種協作機制。也就是說調用線程對象的interrupt方法並不一定就中斷了正在運行的線程，它只是要求線程自己在合適的時機中斷自己。每個線程都有一個boolean的中斷狀態（不一定就是對象的屬性，事實上，該狀態也確實不是Thread的字段），interrupt方法僅僅只是將該狀態置爲true。對於非阻塞中的線程, 只是改變了中斷狀態, 即Thread.isInterrupted()將返回true，並不會使程序停止;

public void run(){//線程t1
   while(true){
      Thread.yield();
   }
}
t1.interrupt();

這樣使線程t1中斷，是不會有效果的，只是更改了中斷狀態位。

如果希望非常優雅地終止這個線程，就該這樣做

public void run(){ 
    while(true)
    { 
        if(Thread.currentThread().isInterrupted())
        { 
           System.out.println("Interruted!"); 
           break; 
        } 
        Thread.yield(); 
    } 
}

使用中斷，就對數據一致性有了一定的保證。

對於可取消的阻塞狀態中的線程, 比如等待在這些函數上的線程, Thread.sleep(), Object.wait(), Thread.join(), 這個線程收到中斷信號後, 會拋出InterruptedException, 同時會把中斷狀態置回爲false.

對於取消阻塞狀態中的線程，可以這樣抒寫代碼：

public void run(){
    while(true){
        if(Thread.currentThread().isInterrupted()){
            System.out.println("Interruted!");
            break;
        }
        try {
           Thread.sleep(2000);
        } catch (InterruptedException e) {
           System.out.println("Interruted When Sleep");
           //設置中斷狀態，拋出異常後會清除中斷標記位
           Thread.currentThread().interrupt();
        }
        Thread.yield();
    }
}

2.5 線程掛起

掛起（suspend）和繼續執行（resume）線程

suspend()不會釋放鎖
如果加鎖發生在resume()之前，則死鎖發生

這兩個方法都是Deprecated方法，不推薦使用。

原因在於，suspend不釋放鎖，因此沒有線程可以訪問被它鎖住的臨界區資源，直到被其他線程resume。因爲無法控制線程運行的先後順序，如果其他線程的resume方法先被運行，那則後運行的suspend，將一直佔有這把鎖，造成死鎖發生。

用以下代碼來模擬這個場景

package test;

public class Test
{
	static Object u = new Object();
	static TestSuspendThread t1 = new TestSuspendThread("t1");
	static TestSuspendThread t2 = new TestSuspendThread("t2");

	public static class TestSuspendThread extends Thread
	{
		public TestSuspendThread(String name)
		{
			setName(name);
		}

		@Override
		public void run()
		{
			synchronized (u)
			{
				System.out.println("in " + getName());
				Thread.currentThread().suspend();
			}
		}
	}

	public static void main(String[] args) throws InterruptedException
	{
		t1.start();
		Thread.sleep(100);
		t2.start();
		t1.resume();
		t2.resume();
		t1.join();
		t2.join();
	}
}

讓t1,t2同時爭奪一把鎖，爭奪到的線程suspend，然後再resume，按理來說，應該某個線程爭奪後被resume釋放了鎖，然後另一個線程爭奪掉鎖，再被resume。

結果輸出是：

in t1
in t2

說明兩個線程都爭奪到了鎖，但是控制檯的紅燈還是亮着的，說明t1,t2一定有線程沒有執行完。我們dump出堆來看看

發現t2一直被suspend。這樣就造成了死鎖。

2.6 join和yeild

yeild是個native靜態方法，這個方法是想把自己佔有的cpu時間釋放掉，然後和其他線程一起競爭(注意yeild的線程還是有可能爭奪到cpu，注意與sleep區別)。在javadoc中也說明了，yeild是個基本不會用到的方法，一般在debug和test中使用。

join方法的意思是等待其他線程結束，就如suspend那節的代碼，想讓主線程等待t1,t2結束以後再結束。沒有結束的話，主線程就一直阻塞在那裏。

package test;

public class Test
{
	public volatile static int i = 0;

	public static class AddThread extends Thread
	{
		@Override
		public void run()
		{
			for (i = 0; i < 10000000; i++)
				;
		}
	}

	public static void main(String[] args) throws InterruptedException
	{
		AddThread at = new AddThread();
		at.start();
		at.join();
		System.out.println(i);
	}
}

如果把上述代碼的at.join去掉，則主線程會直接運行結束，i的值會很小。如果有join,打印出的i的值一定是10000000。

那麼join是怎麼實現的呢？

join的本質

while(isAlive()) 
{ 
   wait(0); 
}

join()方法也可以傳遞一個時間，意爲有限期地等待，超過了這個時間就自動喚醒。

這樣就有一個問題，誰來notify這個線程呢，在thread類中沒有地方調用了notify？

在javadoc中，找到了相關解釋。當一個線程運行完成終止後，將會調用notifyAll方法去喚醒等待在當前線程實例上的所有線程,這個操作是jvm自己完成的。

所以javadoc中還給了我們一個建議，不要使用wait和notify/notifyall在線程實例上。因爲jvm會自己調用，有可能與你調用期望的結果不同。

3. 守護線程

在後臺默默地完成一些系統性的服務，比如垃圾回收線程、JIT線程就可以理解爲守護線程。
當一個Java應用內，所有非守護進程都結束時，Java虛擬機就會自然退出。

此前有寫過一篇python中如何實現，查看這裏。

而Java中變成守護進程就相對簡單了。

Thread t=new DaemonT(); 
t.setDaemon(true); 
t.start();

這樣就開啓了一個守護線程。

package test;

public class Test
{
	public static class DaemonThread extends Thread
	{
		@Override
		public void run()
		{
			for (int i = 0; i < 10000000; i++)
			{
				System.out.println("hi");
			}
		}
	}

	public static void main(String[] args) throws InterruptedException
	{
		DaemonThread dt = new DaemonThread();
		dt.start();
	}
}

當線程dt不是一個守護線程時，在運行後，我們能看到控制檯輸出hi

當在start之前加入

dt.setDaemon(true);

控制檯就直接退出了，並沒有輸出。

4. 線程優先級

Thread類中有3個變量定義了線程優先級。

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
package test;

public class Test
{
	public static class High extends Thread
	{
		static int count = 0;
		@Override
		public void run()
		{
			while (true)
			{
				synchronized (Test.class)
				{
					count++;
					if (count > 10000000)
					{
						System.out.println("High");
						break;
					}
				}
			}
		}
	}
	public static class Low extends Thread
	{
		static int count = 0;
		@Override
		public void run()
		{
			while (true)
			{
				synchronized (Test.class)
				{
					count++;
					if (count > 10000000)
					{
						System.out.println("Low");
						break;
					}
				}
			}
		}
	}

	public static void main(String[] args) throws InterruptedException
	{
		High high = new High();
		Low low = new Low();
		high.setPriority(Thread.MAX_PRIORITY);
		low.setPriority(Thread.MIN_PRIORITY);
		low.start();
		high.start();
	}
}

讓一個高優先級的線程和低優先級的線程同時爭奪一個鎖，看看哪個最先完成。

當然並不一定是高優先級一定先完成。再多次運行後發現，高優先級完成的概率比較大，但是低優先級還是有可能先完成的。

5. 基本的線程同步操作

synchronized 和 Object.wait() Obejct.notify()

這一節內容詳情請看以前寫的一篇Blog

主要要注意的是

synchronized有三種加鎖方式：

指定加鎖對象：對給定對象加鎖，進入同步代碼前要獲得給定對象的鎖。
直接作用於實例方法：相當於對當前實例加鎖，進入同步代碼前要獲得當前實例的鎖。
直接作用於靜態方法：相當於對當前類加鎖，進入同步代碼前要獲得當前類的鎖。

作用於實例方法，則不要new兩個不同的實例

作用於靜態方法，只要類一樣就可以了，因爲加的鎖是類.class，可以new兩個不同實例。

wait和notify的用法：

用什麼鎖住，就用什麼調用wait和notify

本文就不細說了。

高併發Java 二多線程基

1. 什麼是線程

2. 線程的基本操作

2.1 線程狀態圖

2.2 新建線程

2.3 終止線程

2.4 線程中斷

2.5 線程掛起

2.6 join和yeild

3. 守護線程

4. 線程優先級

5. 基本的線程同步操作

synchronized 和 Object.wait() Obejct.notify()

windows上寫的腳本，結果到linux上運行報錯

高併發Java 二多線程基

openstack neutron軟件架構

openstack neutron基本原理

爲什麼重寫equals方法必須重寫hashcode

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

高併發Java 二 多線程基

1. 什麼是線程

2. 線程的基本操作

2.1 線程狀態圖

2.2 新建線程

2.3 終止線程

2.4 線程中斷

2.5 線程掛起

2.6 join和yeild

3. 守護線程

4. 線程優先級

5. 基本的線程同步操作

synchronized 和 Object.wait() Obejct.notify()

高併發Java 二多線程基