摘要：多線程進程正在進行中的程序。所以容易出現線程安全問題。等待喚醒機制涉及的方法將同步中的線程處于凍結狀態。返回該線程的字符串表示形式，包括線程名稱優先級和線程組。暫停當前正在執行的線程對象，并執行其他線程。

多線程：
進程：正在進行中的程序。其實進程就是一個應用程序運行時的內存分配空間。
線程：其實就是進程中一個程序執行控制單元，一條執行路徑。進程負責的是應用程序的空間的標示。線程負責的是應用程序的執行順序。

一個進程至少有一個線程在運行，當一個進程中出現多個線程時，就稱這個應用程序是多線程應用程序，每個線程在棧區中都有自己的執行空間，自己的方法區、自己的變量。
jvm在啟動的時，首先有一個主線程，負責程序的執行，調用的是main函數。主線程執行的代碼都在main方法中。
當產生垃圾時，收垃圾的動作，是不需要主線程來完成，因為這樣，會出現主線程中的代碼執行會停止，會去運行垃圾回收器代碼，效率較低，所以由多帶帶一個線程來負責垃圾回收。

隨機性的原理：因為cpu的快速切換造成，哪個線程獲取到了cpu的執行權，哪個線程就執行。

返回當前線程的名稱：Thread.currentThread().getName()
線程的名稱是由：Thread-編號定義的。編號從0開始。
線程要運行的代碼都統一存放在了run方法中。

線程要運行必須要通過類中指定的方法開啟。start方法。（啟動后，就多了一條執行路徑）
start方法：1）、啟動了線程；2）、讓jvm調用了run方法。

創建線程的第一種方式：繼承Thread ，由子類復寫run方法。
步驟：
1，定義類繼承Thread類；
2，目的是復寫run方法，將要讓線程運行的代碼都存儲到run方法中；
3，通過創建Thread類的子類對象，創建線程對象；
4，調用線程的start方法，開啟線程，并執行run方法。

線程狀態：
被創建：start()
運行：具備執行資格，同時具備執行權；
凍結：sleep(time),wait()—notify()喚醒；線程釋放了執行權，同時釋放執行資格；
臨時阻塞狀態：線程具備cpu的執行資格，沒有cpu的執行權；
消亡：stop()

創建線程的第二種方式：實現一個接口Runnable。
步驟：
1，定義類實現Runnable接口。
2，覆蓋接口中的run方法（用于封裝線程要運行的代碼）。
3，通過Thread類創建線程對象；
4，將實現了Runnable接口的子類對象作為實際參數傳遞給Thread類中的構造函數。
為什么要傳遞呢？因為要讓線程對象明確要運行的run方法所屬的對象。
5，調用Thread對象的start方法。開啟線程，并運行Runnable接口子類中的run方法。
Ticket t = new Ticket();
/*
直接創建Ticket對象，并不是創建線程對象。
因為創建對象只能通過new Thread類，或者new Thread類的子類才可以。
所以最終想要創建線程。既然沒有了Thread類的子類，就只能用Thread類。
*/
Thread t1 = new Thread(t); //創建線程。
/*
只要將t作為Thread類的構造函數的實際參數傳入即可完成線程對象和t之間的關聯
為什么要將t傳給Thread類的構造函數呢？其實就是為了明確線程要運行的代碼run方法。
*/
t1.start();

為什么要有Runnable接口的出現？
1：通過繼承Thread類的方式，可以完成多線程的建立。但是這種方式有一個局限性，如果一個類已經有了自己的父類，就不可以繼承Thread類，因為java單繼承的局限性。
可是該類中的還有部分代碼需要被多個線程同時執行。這時怎么辦呢？
只有對該類進行額外的功能擴展，java就提供了一個接口Runnable。這個接口中定義了run方法，其實run方法的定義就是為了存儲多線程要運行的代碼。
所以，通常創建線程都用第二種方式。
因為實現Runnable接口可以避免單繼承的局限性。

2：其實是將不同類中需要被多線程執行的代碼進行抽取。將多線程要運行的代碼的位置多帶帶定義到接口中。為其他類進行功能擴展提供了前提。
所以Thread類在描述線程時，內部定義的run方法，也來自于Runnable接口。

//面試
new Thread(new Runnable(){ //匿名
public void run(){
System.out.println("runnable run");
}
})
{
public void run(){
System.out.println("subthread run");
}

Try {
Thread.sleep(10);
}catch(InterruptedException e){}// 當刻意讓線程稍微停一下，模擬cpu切換情況。

多線程安全問題的原因：
通過圖解：發現一個線程在執行多條語句時，并運算同一個數據時，在執行過程中，其他線程參與進來，并操作了這個數據。導致到了錯誤數據的產生。

涉及到兩個因素：
1，多個線程在操作共享數據。
2，有多條語句對共享數據進行運算。
原因：這多條語句，在某一個時刻被一個線程執行時，還沒有執行完，就被其他線程執行了。

解決安全問題的原理：
只要將操作共享數據的語句在某一時段讓一個線程執行完，在執行過程中，其他線程不能進來執行就可以解決這個問題。

如何進行多句操作共享數據代碼的封裝呢？
java中提供了一個解決方式：就是同步代碼塊。
格式：
synchronized(對象) { // 任意對象都可以。這個對象就是鎖。
需要被同步的代碼；

同步：★★★★★
好處：解決了線程安全問題。
弊端：相對降低性能，因為判斷鎖需要消耗資源，產生了死鎖。

定義同步是有前提的：
1，必須要有兩個或者兩個以上的線程，才需要同步。
2，多個線程必須保證使用的是同一個鎖。

同步的第二種表現形式：
同步函數：其實就是將同步關鍵字定義在函數上，讓函數具備了同步性。

同步函數是用的哪個鎖呢？
通過驗證，函數都有自己所屬的對象this，所以同步函數所使用的鎖就是this鎖。

當同步函數被static修飾時，這時的同步用的是哪個鎖呢？
靜態函數在加載時所屬于類，這時有可能還沒有該類產生的對象，但是該類的字節碼文件加載進內存就已經被封裝成了對象，這個對象就是該類的字節碼文件對象。
所以靜態加載時，只有一個對象存在，那么靜態同步函數就使用的這個對象。
這個對象就是 類名.class

同步代碼塊和同步函數的區別？
同步代碼塊使用的鎖可以是任意對象。
同步函數使用的鎖是this，靜態同步函數的鎖是該類的字節碼文件對象。

★考點問題：請寫一個延遲加載的單例模式？寫懶漢式；當出現多線程訪問時怎么解決？加同步，解決安全問題；效率高嗎？不高；怎樣解決？通過雙重判斷的形式解決。
//懶漢式：延遲加載方式。
當多線程訪問懶漢式時，因為懶漢式的方法內對共性數據進行多條語句的操作。所以容易出現線程安全問題。為了解決，加入同步機制，解決安全問題。但是卻帶來了效率降低。
為了效率問題，通過雙重判斷的形式解決。
class Single{
private static Single s = null;
private Single(){}
public static Single getInstance(){ //鎖是誰？字節碼文件對象；
if(s == null){
synchronized(Single.class){
if(s == null)
s = new Single();
}
}
return s;
}

同步死鎖：通常只要將同步進行嵌套，就可以看到現象。同步函數中有同步代碼塊，同步代碼塊中還有同步函數。

線程間通信：思路：多個線程在操作同一個資源，但是操作的動作卻不一樣。
1：將資源封裝成對象。
2：將線程執行的任務(任務其實就是run方法。)也封裝成對象。

等待喚醒機制：涉及的方法：
wait:將同步中的線程處于凍結狀態。釋放了執行權，釋放了資格。同時將線程對象存儲到線程池中。
notify：喚醒線程池中某一個等待線程。
notifyAll:喚醒的是線程池中的所有線程。

注意：
1：這些方法都需要定義在同步中。
2：因為這些方法必須要標示所屬的鎖。
你要知道 A鎖上的線程被wait了,那這個線程就相當于處于A鎖的線程池中，只能A鎖的notify喚醒。
3：這三個方法都定義在Object類中。為什么操作線程的方法定義在Object類中？
因為這三個方法都需要定義同步內，并標示所屬的同步鎖，既然被鎖調用，而鎖又可以是任意對象，那么能被任意對象調用的方法一定定義在Object類中。

wait和sleep區別： 分析這兩個方法：從執行權和鎖上來分析：
wait：可以指定時間也可以不指定時間。不指定時間，只能由對應的notify或者notifyAll來喚醒。
sleep：必須指定時間，時間到自動從凍結狀態轉成運行狀態(臨時阻塞狀態)。
wait：線程會釋放執行權，而且線程會釋放鎖。
Sleep：線程會釋放執行權，但不是不釋放鎖。

線程的停止：通過stop方法就可以停止線程。但是這個方式過時了。
停止線程：原理就是：讓線程運行的代碼結束，也就是結束run方法。
怎么結束run方法？一般run方法里肯定定義循環。所以只要結束循環即可。
第一種方式：定義循環的結束標記。
第二種方式：如果線程處于了凍結狀態，是不可能讀到標記的，這時就需要通過Thread類中的interrupt方法，將其凍結狀態強制清除。讓線程恢復具備執行資格的狀態，讓線程可以讀到標記，并結束。

---------< java.lang.Thread >----------
interrupt()：中斷線程。
setPriority(int newPriority)：更改線程的優先級。
getPriority()：返回線程的優先級。
toString()：返回該線程的字符串表示形式，包括線程名稱、優先級和線程組。
Thread.yield()：暫停當前正在執行的線程對象，并執行其他線程。
setDaemon(true)：將該線程標記為守護線程或用戶線程。將該線程標記為守護線程或用戶線程。當正在運行的線程都是守護線程時，Java 虛擬機退出。該方法必須在啟動線程前調用。
join：臨時加入一個線程的時候可以使用join方法。

Lock接口：多線程在JDK1.5版本升級時，推出一個接口Lock接口。
解決線程安全問題使用同步的形式，(同步代碼塊，要么同步函數)其實最終使用的都是鎖機制。

到了后期版本，直接將鎖封裝成了對象。線程進入同步就是具備了鎖，執行完，離開同步，就是釋放了鎖。
在后期對鎖的分析過程中，發現，獲取鎖，或者釋放鎖的動作應該是鎖這個事物更清楚。所以將這些動作定義在了鎖當中，并把鎖定義成對象。

所以同步是隱示的鎖操作，而Lock對象是顯示的鎖操作，它的出現就替代了同步。

在之前的版本中使用Object類中wait、notify、notifyAll的方式來完成的。那是因為同步中的鎖是任意對象，所以操作鎖的等待喚醒的方法都定義在Object類中。

而現在鎖是指定對象Lock。所以查找等待喚醒機制方式需要通過Lock接口來完成。而Lock接口中并沒有直接操作等待喚醒的方法，而是將這些方式又多帶帶封裝到了一個對象中。這個對象就是Condition，將Object中的三個方法進行多帶帶的封裝。并提供了功能一致的方法 await()、signal()、signalAll()體現新版本對象的好處。

class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {

 lock.lock();
 try {
   while (count == items.length)
     notFull.await();
   items[putptr] = x;
   if (++putptr == items.length) putptr = 0;
   ++count;
   notEmpty.signal();
 }

finally {

   lock.unlock();
 }

}
public Object take() throws InterruptedException {

 lock.lock();
 try {
   while (count == 0)
     notEmpty.await();
   Object x = items[takeptr];
   if (++takeptr == items.length) takeptr = 0;
   --count;
   notFull.signal();
   return x;
 }

finally {

   lock.unlock();
 }

}