關於synchronized的理解，共有兩種型別的鎖：
（1）類鎖：只有synchronized修飾靜態方法或者修飾一個類的class物件時，才是類鎖。
（2）物件鎖：除了類鎖，所有其他的上鎖方式都認為是物件鎖。比如synchronized修飾普通方法或者synchronized（this)給程式碼塊上鎖等。
應該注意的是，因為一個類只有一個class物件，因此所有的訪問者在訪問被加了類鎖的程式碼時，都是共用同一把鎖，而類的例項卻可以有很多個，因此不同物件訪問加了物件鎖的程式碼，它們的訪問互不干擾。
synchronized鎖的訪問規則
（1）加了相同鎖的程式碼，它們的訪問規則是相同的，即當某個訪問者獲得該鎖時，它們一起向該訪問者開放訪問，向其他沒有獲得該鎖的訪問者關閉訪問。
（2）加了不同鎖的程式碼訪問互相不干擾。
（3）而沒有加鎖的程式碼隨時都可以任意訪問，不受任何限制。
判斷是否同一把synchronized鎖
（1）不同型別的鎖不是同一把鎖。
（2）加的是物件鎖，那麼必須是同一個物件例項才是同一把鎖。
（3）加的是類鎖，那必須是同一類才是同一把鎖。
對於synchronized修飾的程式碼能否訪問
1.首先判斷是不是同一把鎖。
2.然後判斷各自的訪問規則。
注意事項
雖然synchronized關鍵字可以來修飾方法，但synchronized關鍵字不屬於方法定義的一部分。synchronized關鍵字不能被繼承。如果在父類中的某個方法使用了synchronized關鍵字，子類又覆蓋了該方法，在子類中的方法預設情況下是不進行同步的，而必須顯示在子類的方法上也加上synchronized關鍵字才可以。當然，也可以在子類中直接呼叫父類方法，這樣雖然子類方法不同步但是方法體的內容，是同步的，因此相當於子類方法也同步。
多執行緒程式設計步驟(上)
第一，建立資源類，建立屬性和操作方法。第二 建立多執行緒呼叫資源類的方法。
售票案例
sale 銷售 ticket 票
案例要求，3個售票員進行售票，共售賣30張票。
程式碼
/**
-
@author 長名06
-
@version 1.0
-
多執行緒程式設計步驟，第一步 建立資源類，定義屬性和方法
-
第二步，建立多個執行緒，呼叫資源類的操作方法
*/
public class SaleTickets {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(() -> {
for (int i = 0; i < 40; i++){
ticket.sale();
}
}, "aa").start();new Thread(() -> { for (int i = 0; i < 40; i++){ ticket.sale(); } }, "bb").start(); new Thread(() -> { for (int i = 0; i < 40; i++){ ticket.sale(); } }, "cc").start();}
}
class Ticket {
//票數
//程式碼效果參考：https://www.yopian.com/sitemap/post.xml
private static int number = 30;
public synchronized void sale() {
if (number > 0) {
System.out.println(Thread.currentThread().getName() + "\t 賣出一張票"
+ "剩下票數為" + --number);
}
}
}
程式碼分析
1.synchronized關鍵字修飾的非靜態方法，此時這個方法的鎖就是synchronized(this)鎖，就是對呼叫當前方法的物件上鎖。案例中的aa，bb，cc執行緒都是使用ticket這同一個物件，呼叫的sale()方法，所以這三個執行緒是互斥的，同時只能由三個中的一個，使用sale()方法。從輸出結果，也可以看出，是互斥訪問的。
2.當一個執行緒獲取了對應的鎖，可以訪問對應鎖的程式碼塊，其他需要訪問該程式碼塊的執行緒，就要等待。等待獲取鎖的執行緒釋放鎖，但是獲取到鎖的執行緒的執行有兩種情況。
1）獲取鎖的執行緒，執行對應的程式碼塊，然後執行緒釋放鎖，無事發生，正常情況；
2）擁有鎖的執行緒執行中，出現了異常，此時JVM會讓執行緒自動釋放鎖。
3.但如果獲取鎖的執行緒的操作，需要等待IO或者其他原因(如sleep方法)被阻塞了，但是執行緒沒有釋放鎖，其他的執行緒就只能等待，會很影響執行效率。所以需要一種機制可以不讓等待的執行緒一直無限的等待下去(等待一定的時間，就能響應中斷)，透過Lock(java.util.concurrent.locks包下的介面)就可以實現。
4.以上鎖都是synchronized鎖。
Lock
基本介紹
Lock鎖實現，並提供了比使用同步方法和語句可以獲得的更廣泛的鎖操作。它們允許更靈活的結構，可能具有非常不同的屬性，並且可能支援多個關聯的條件物件。Lock提供了比synchronized更多的功能。
Lock和synchronized的區別
1.Lock不是java語言內建的關鍵字，synchronized是Java語言的關鍵字，是內建特性。Lock是一個介面，可以透過其實現類實現非同步訪問。
2.採用synchronized關鍵字，不需要使用者去手動釋放鎖，當synchronized關鍵字修飾的方法或程式碼塊執行完之後，有JVM自動讓執行緒釋放鎖。但是Lock則必須讓使用者手動釋放鎖，如果沒有主動釋放鎖，就可能會出現死鎖現象。
使用Lock實現sale_ticket案例
import java.util.concurrent.locks.ReentrantLock;
/**
-
@author 長名06
-
@version 1.0
-
多執行緒程式設計步驟，第一步 建立資源類，定義屬性和方法
-
第二步，建立多個執行緒，呼叫資源類的操作方法
*/
public class SaleTickets {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(() -> {
for (int i = 0; i < 40; i++){
ticket.sale();
}
}, "aa").start();new Thread(() -> { for (int i = 0; i < 40; i++){ ticket.sale(); } }, "bb").start(); new Thread(() -> { for (int i = 0; i < 40; i++){ ticket.sale(); } }, "cc").start();}
}
class Ticket {
//票數
private static int number = 30;
private final ReentrantLock lock = new ReentrantLock();
public void sale() {
lock.lock();//開啟鎖
try {
if (number > 0) {
System.out.println(Thread.currentThread().getName() + "\t 賣出一張票"
+ "剩下票數為" + --number);
}
}finally {
lock.unlock();//釋放鎖
}
}
}
關於Thread#start()&start0()
public synchronized void start() {//這個方法，完成執行緒的啟動，但是實際建立執行緒是start0()方法完成的
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();//這裡這個方法的呼叫，才是完成執行緒的建立
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
private native void start0();//此方法，java程式碼無法完成，而是用native關鍵字修飾的方法，就是使用jvm底層的JNI(Java Native Interface)機制呼叫c語言庫完成的。這個建立執行緒的方法，以及是否建立，建立順序，不是由java程式決定的，而是由程式執行的OS決定的。
lock介面方法
public interface Lock {
void lock();//獲取鎖
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();//釋放鎖
Condition newCondition();
}
lock方法
lock()方法使用最多的方法，功能，獲取鎖，如果鎖被其他執行緒獲取，則進行等待。
使用Lock，必須主動去釋放鎖，並且發生異常時，不會自動釋放鎖。因此一般來說，使用Lock必須在try{}catch{}finally{}塊中進行，並且將釋放鎖的操作在finally塊中，用來保證鎖一定被釋放，防止死鎖的發生。通常使用Lock實現同步的，是以如下形式的。
lock.lock();//開啟鎖
try {
//...具體程式碼
}catch(Exception e){
}
finally {
lock.unlock();//釋放鎖
}
newCondition方法
關鍵字synchronized和wait()/notify()這兩個方法一起使用，可實現等待/通知模式。Lock鎖的newCondition()方法返回Condition物件，Condition類也可以實現等待/通知的模式。wait()和notify()是Object類下的方法，notify()被呼叫時，JVM會隨機的喚醒某個等待的執行緒，使用Condition類可進行選擇性通知，Condition常用的方法，awiat()方法，會使當前執行緒等待，同時會釋放當前執行緒持有的鎖，當其他執行緒呼叫signal()時，執行緒會重新獲得鎖並繼續執行。signal()用於喚醒等待的執行緒。
注意，在使用Condition介面(使用其具體的實現類)的await()和signa()方法前，需要執行緒持有相關的Lock鎖，呼叫await()後執行緒會釋放這個鎖，在signal()呼叫後會從當前Condition物件的等待佇列中，喚醒一個執行緒，喚醒的執行緒嘗試獲得鎖，一旦獲得鎖成功，就執行。
小結
Lock和synchronized有以下幾點不同
1.Lock是一個介面，而synchronized是Java中的關鍵字，synchronized是內建的語言實現的。
2.synchronized在發生異常時，會自動釋放執行緒佔有的鎖，因此不會導致死鎖現象發生。Lock在發生異常時，如果沒有主動透過unLock()會釋放鎖，則很可能會造成死鎖現象，因此使用Lock時需要在finally塊中釋放鎖。
3.Lock可以讓等待鎖的執行緒響應中斷，而synchronized卻不行，使用synchronized時，等待的執行緒會一致等待，不能夠使用中斷。
4.透過Lock可以知道有沒有成功獲取鎖，而synchronized卻無法辦到。
5.Lock可以提高多個執行緒進行讀操作的效率。
在效能上來說，如果資源競爭不激烈，二者的效能是差不多的，而當資源競爭激烈時，此時Lock的效能要遠遠優於synchronized。