1.執行緒與多執行緒的概念：在一個程式中，能夠獨立執行的程式片段叫作“執行緒”（Thread）。多執行緒（multithreading）是指從軟體或者硬體上實現多個執行緒併發執行的技術。

2.多執行緒的意義：多執行緒可以在時間片裡被cpu快速切換，資源能更好被呼叫、程式設計在某些情況下更簡單、程式響應更快、執行更加流暢。

2.如何啟動一個執行緒：繼承Thread類、實現Runnable介面、實現Callable介面

3.為什麼要保證執行緒的同步？：java允許多執行緒併發控制，當多個執行緒同時操作一個可共享的資源變數時（如資料的增刪改查），將會導致資料不準確，相互之間產生衝突，因此加入同步鎖以避免在該執行緒沒有完成操作之前，被其他執行緒的呼叫，從而保證了該變數的唯一性和準確性。

4.基本的執行緒同步：使用synchronized關鍵字、特殊域變數volatile、wait和notify方法等。

public class T {
    private int count=10;
    private Object o=new Object();

    public void m(){
        synchronized (o){
            //任何執行緒要執行下面的程式碼，必須先拿到o的鎖
            count--;
            System.out.println(Thread.currentThread().getName()+"count="+count);
        }
    }
}

假設這段程式碼中有多個執行緒，當第一個執行緒執行到m方法來的時候，sync鎖住了堆記憶體中的o物件，這個時候第二個執行緒是進不來的，它必須等第一個執行緒執行完，鎖釋放掉才可以接著執行。這裡有個鎖的概念叫做互斥鎖，sync是一種互斥鎖。

public class T1 {
    private static int count =10;

    public synchronized static void m(){
        //這裡等同於synchronized(T3.class)
        count--;
        System.out.println(Thread.currentThread().getName()+"count="+count);
    }

    public static void mm(){
        synchronized (T1.class){
            //思考：這裡寫成synchronized(this)是否可以？
            count--;
        }
    }
}

思考這裡，注意sync修飾的是一個靜態方法和靜態的屬性，靜態修飾的方法和屬性是不需要new出物件來就可以訪問的，所以這裡沒有new出物件，sync鎖定的是T3.class物件。

public class T2 implements Runnable{
    private int count =10;

    @Override
    public /*synchronized*/ void run(){
        count--;
        System.out.println(Thread.currentThread().getName()+"count="+count);
    }

    public static void main(String[] args) {
        T2 t=new T2();
        for (int i=0;i<5;i++){
            new Thread(t,"THREAD"+i).start();
        }
    }
}

上面程式碼中開啟了五個執行緒，執行run方法對count進行減一的操作，這裡會出現執行緒搶佔資源的問題。當第一個執行緒在執行run方法時，減減的過程中，第二個執行緒也進入了方法，同樣也在執行減減，可能會出現第二個執行緒減完的時候，第一個執行緒才輸出count，這時候就出現了執行緒重入。處理方法可以加上synchronized關鍵字，只有等第一個執行緒執行完畢，第二個執行緒才可以進入，即同一時刻只能有一個執行緒來對它進行操作，也就是原子性。

public class Account {

    /**
     * 賬號持有人和賬號餘額
     */
    String name;
    double balance;

    /**
     * 設定賬號餘額，執行緒睡眠目的是先讓它讀資料
     * @param name
     * @param balance
     */
    public synchronized void set(String name,double balance){
        this.name=name;

        try {
            Thread.sleep(2000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        this.balance=balance;
    }

    public double getBalance(String name){
        return this.balance;
    }

    public static void main(String[] args) {
        Account a=new Account();
        new Thread(()->a.set("zhangsan",100.0)).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(a.getBalance("zhangsan"));

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(a.getBalance("zhangsan"));
    }
}

這是一個小demo，程式碼中只對set方法加了鎖，沒有對get方法加鎖，這個時候會出現髒讀現象。解決方法是讀和寫的方法都加鎖。

public class T3 {

    synchronized void m1(){
        System.out.println("m1 start");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        m2();
    }

    synchronized void m2() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("m2");
    }
}

這個案例中，m1和m2方法都已經加上了鎖，當執行m1的時候再去執行m2，這樣是可以的。一個同步方法可以呼叫另外一個同步方法，也就是說sync獲得的鎖是可重入鎖。還有個概念是死鎖，死鎖是指多個執行緒搶佔資源而造成的一種互相等待。舉個例子，一個箱子需要兩把鑰匙才可以開啟，鑰匙分別在兩個人手中，這兩個人互相搶佔另外一個人的鑰匙，導致箱子打不