1，為什麼需要執行緒?

作用：提升cpu的利用率，如，早期的dos系統，執行2個命令時( command 1, command 2 )，如果command1【假如是磁碟遍歷檔案的IO操作】執行的時間比較長，那麼command 2必須等待，這種方式就是同步阻塞，

cpu就閒置了，為了提高cpu的利用率，我們就要使用多執行緒，如果一個任務時間比較長，cpu就暫時掛起他，去執行另外的執行緒，所以執行緒一般是非同步的。

2，每一個程序至少會有一個執行緒在執行

public class Test {

    public static void main(String[] args) {
        
 
//列印執行緒的名稱
        System.out.println( Thread.currentThread().getName() );
        
    }

}

輸出結果為 "main" ，注意這個main是執行緒的名字，跟main函式的名字相同而已。

3，在java中實現多執行緒有2種方式

>繼承Thread類

>實現Runnable介面

在run方法中寫執行緒要執行的任務

class MyThread extends Thread{
    public void run(){
        System.out.println( 
 
"MyThread::run" );
    }
}

public class ThreadUse1 {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        System.out.println( "執行結束" );
    }

}

從執行結果可知，run方法是在之後執行的，雖然start開啟執行緒比  【System.out.println( "執行結束" );】 他早，這說明，CPU在呼叫執行緒的時候，是隨機的

4，再次驗證cpu呼叫執行緒的隨機性

class MyThreadRand extends Thread{
    public void run(){
        try{
            for ( int i = 0; i < 10; i++ ) {
                int time = ( int )( Math.random() * 1000 );
                Thread.sleep( time );
                System.out.println( "MyThread:" + Thread.currentThread().getName() );
            }
        }catch( InterruptedException e ){
            e.printStackTrace();
        }
    }
}

public class RandThread {

    public static void main(String[] args) {
        
        try{
            MyThreadRand mt = new MyThreadRand();
            mt.setName( "自定義執行緒" );
            mt.start();
            for ( int i = 0; i < 10; i++ ) {
                int time = ( int )( Math.random() * 1000 );
                Thread.sleep( time );
                System.out.println( "MainThread:" + Thread.currentThread().getName() );
            }
        }catch( InterruptedException e ){
            e.printStackTrace();
        }
    }

}

從執行結果可知，執行緒的排程沒有什麼規律，是隨機的， 這裡補充一點，start方法作用是通知 “執行緒規劃器”，這個執行緒已經準備好了，等待呼叫執行緒的run方法，就是讓系統安排一個時間來呼叫run方法。如果直接呼叫run方法，執行緒就變成同步方式了，必須等待MyThreadRand的run方法執行完成之後，才會執行main函式中的執行緒

5，start方法的順序，不代表執行緒的啟動順序

class MyThreadStart extends Thread{
    private int i;
    public MyThreadStart( int i ) {
        this.i = i;
    }
    public void run(){
        System.out.println( i );
    }
}

public class RandThread2 {

    public static void main(String[] args) {
        MyThreadStart s1 = new MyThreadStart( 1 );
        MyThreadStart s2 = new MyThreadStart( 2 );
        MyThreadStart s3 = new MyThreadStart( 3 );
        MyThreadStart s4 = new MyThreadStart( 4 );
        MyThreadStart s5 = new MyThreadStart( 5 );
        MyThreadStart s6 = new MyThreadStart( 6 );
        MyThreadStart s7 = new MyThreadStart( 7 );
        MyThreadStart s8 = new MyThreadStart( 8 );
        MyThreadStart s9 = new MyThreadStart( 9 );
        MyThreadStart s10 = new MyThreadStart( 10 );
        
        s1.start();
        s2.start();
        s3.start();
        s4.start();
        s5.start();
        s6.start();
        s7.start();
        s8.start();
        s9.start();
        s10.start();
    }

}

6，實現Runnable介面

class MyThreadRunnable implements Runnable {
    public void run(){
        System.out.println( Thread.currentThread().getName() );
    }
}

public class ThreadRunnable {

    public static void main(String[] args) {

        MyThreadRunnable mt = new MyThreadRunnable();
        Thread t = new Thread( mt );
        t.setName( "自定義執行緒1" );
        t.start();
    }

}

那麼兩種多執行緒的實現方式，有什麼不同呢？

>繼承Thread類

>實現Runnable介面

1，使用繼承Thread類的方式，多執行緒之間的資料不共享

class MyThreadShare extends Thread{
    private int count = 5;
    public MyThreadShare( String name ){
        this.setName( name );
    }
    public void run(){
        while( count-- > 0 ){
            System.out.println( Thread.currentThread().getName() + "->" + count );
        }
    }
}

public class ThreadShare {
    public static void main(String[] args) {        
        MyThreadShare mt1 = new MyThreadShare( "A" );
        MyThreadShare mt2 = new MyThreadShare( "B" );
        MyThreadShare mt3 = new MyThreadShare( "C" );
        
        mt1.start();
        mt2.start();
        mt3.start();
    }
}

2，而要想實現執行緒之間的資料共享，我們可以改一下

備註：執行緒資料共享與不共享，都有對應的場景，比如火車站4個視窗賣票，很顯然需要執行緒共享資料。如：總共用10張票，如果視窗賣了1張，其他視窗就指剩下9張，這才是比較貼近實際的，如果用第一種方式，相當於有40張餘票了。

class MyThreadShare2 extends Thread{
    private int count = 5;    
    public void run(){
        while( count-- > 0 ){
            System.out.println( Thread.currentThread().getName() + "->" + count );
        }
    }
}

public class ThreadShare2 {
    public static void main(String[] args) {        
        
        MyThreadShare2 mt = new MyThreadShare2();
        Thread ta = new Thread( mt, "A" );
        Thread tb = new Thread( mt, "B" );
        Thread tc = new Thread( mt, "C" );
        
        ta.start();
        tb.start();
        tc.start();
        
    }
}

從結果上看，好像實現了，資料共享，但是有點異常，B->3 很明顯不對，這種現象，在多執行緒程式設計裡面，叫“執行緒非安全”。現實生活中也有類似場景，比如4S店賣車，兩個客戶同時預訂了這輛車。那估計少不了一番辯論。怎麼解決這個問題呢？一般來說，在客戶訂車之前，銷售員要先檢視庫存，如果客戶下單，要把庫存佔用。表明有人預訂，其他銷售員看見了，就知道車被預訂了。程式中也是類似。如果要訪問這個變數，我們就給他加鎖，類似於銷售員佔用庫存。在方法前加上synchronized關鍵字。那麼其他執行緒訪問的時候，必須拿到這把鎖，才能訪問。synchronized可以在任意物件或者方法上加鎖。

class MyThreadShare2 extends Thread{
    private int count = 5;    
//    public void run(){  //產生執行緒非安全問題
    synchronized public void run(){
        while( count-- > 0 ){
            System.out.println( Thread.currentThread().getName() + "->" + count );
        }
    }
}

public class ThreadShare2 {
    public static void main(String[] args) {        
        
        MyThreadShare2 mt = new MyThreadShare2();
        Thread ta = new Thread( mt, "A" );
        Thread tb = new Thread( mt, "B" );
        Thread tc = new Thread( mt, "C" );
        
        ta.start();
        tb.start();
        tc.start();
        
    }
}

 3，模擬使用者登入場景，如果有兩個使用者登入，我們讓其中一個使用者執行緒佔時掛起。看下會出現什麼情況

class Login {
    private static String userName;
    private static String userPwd;
    
    public static void doPost( String _userName, String _userPwd ){
        try {
            userName = _userName;
            if( userName.equals( "ghostwu" ) ) {
                Thread.sleep( 3000 );                
            }
            userPwd = _userPwd;
            System.out.println( userName + "---->" + userPwd );
        }catch( InterruptedException e ){
            e.printStackTrace();
        }
    }
}

class ThreadA extends Thread{
    public void run(){
        Login.doPost( "ghostwu", "abc123" );
    }
}

class ThreadB extends Thread{
    public void run(){
        Login.doPost( "ghostwuB", "abc1234" );
    }
}

public class UserLogin {

    public static void main(String[] args) {
        
        ThreadA ta = new ThreadA();
        ThreadB tb = new ThreadB();
        
        ta.start();
        tb.start();
    }

}

在A執行緒掛起的時候，他之前的賦值已經被B執行緒改變了，所以結果與預想的ghostwu  abc123不同。很明顯，我們要上鎖。

synchronized public static void doPost( String _userName, String _userPwd ){
        try {
            userName = _userName;
            if( userName.equals( "ghostwu" ) ) {
                Thread.sleep( 3000 );                
            }
            userPwd = _userPwd;
            System.out.println( userName + "---->" + userPwd );
        }catch( InterruptedException e ){
            e.printStackTrace();
        }
    }