1、程序、進(jìn)程、線程

程序：是指令和數(shù)據(jù)的有序集合，其本身沒(méi)有任何運(yùn)行的含義，是一個(gè)靜態(tài)的概念。

進(jìn)程（Process）：是執(zhí)行程序的一次執(zhí)行過(guò)程，是一個(gè)動(dòng)態(tài)的概念，是系統(tǒng)資源分配的單位。

線程（Thread）：通常在一個(gè)進(jìn)程中可以包含若干個(gè)線程，一個(gè)進(jìn)程中至少有一個(gè)線程，不然沒(méi)有存在的意義。線程是CPU調(diào)度和執(zhí)行的單位。

很多多線程是模擬出來(lái)的，真正的多線程是指有多個(gè)cpu，即多核，如服務(wù)器。如果是模擬出來(lái)的多線程，即在一個(gè)cpu的情況下，在同一時(shí)間點(diǎn)，cpu只能執(zhí)行一個(gè)代碼，因?yàn)榍袚Q的很快，所以就有同時(shí)執(zhí)行的錯(cuò)覺(jué)。

• 線程就是獨(dú)立的執(zhí)行路徑；
• 在程序運(yùn)行時(shí)，即使沒(méi)有自己創(chuàng)建線程，后臺(tái)也會(huì)有多個(gè)線程，如主線程，gc線程；
• main()稱(chēng)之為主線程，為系統(tǒng)的入口，用于執(zhí)行整個(gè)程序；
• 在一個(gè)進(jìn)程中，如果開(kāi)辟了多個(gè)線程，線程的運(yùn)行由調(diào)度器安排調(diào)度，調(diào)度器是與操作系統(tǒng)緊密相關(guān)的，先后順序是不能人為的干預(yù)的；
• 對(duì)同一份資源操作時(shí)，會(huì)存在資源搶奪的問(wèn)題，需要加入并發(fā)控制；
• 線程會(huì)帶來(lái)額外的開(kāi)銷(xiāo)，如cpu調(diào)度時(shí)間，并發(fā)控制開(kāi)銷(xiāo)；
• 每個(gè)線程在自己的工作內(nèi)存交互，內(nèi)存控制不當(dāng)會(huì)造成數(shù)據(jù)不一致。

2、線程的創(chuàng)建

• Thread class——->繼承Thread類(lèi)
• Runnable接口——>實(shí)現(xiàn)Runnable接口
• Callable接口——>實(shí)現(xiàn)Callable接口

方式一：（1）自定義線程類(lèi)繼承Thread類(lèi)；（2）重寫(xiě)run()方法，編寫(xiě)線程執(zhí)行體；（3）創(chuàng)建線程對(duì)象，調(diào)用start()方法啟動(dòng)線程

  public class StartThread extends Thread{ //1、自定義線程類(lèi)繼承Thread類(lèi)
      @Override //2、重寫(xiě)run()方法，編寫(xiě)線程執(zhí)行體
      public void run() {
          for (int i = 0; i < 100; i++) {
              System.out.println("run"+i);
          }
      }
      public static void main(String[] args) {
         StartThread startThread = new StartThread();
         startThread.start(); //3、創(chuàng)建線程對(duì)象，調(diào)用start()方法啟動(dòng)線程
         for (int i = 0; i < 500; i++) {
             System.out.println("main"+i);
         }
     }
 }

線程不一定立即執(zhí)行，由CPU安排調(diào)度

方式二：（1）自定義線程類(lèi)實(shí)現(xiàn)Runnable接口；（2）實(shí)現(xiàn)run()方法，編寫(xiě)線程執(zhí)行體；（3）創(chuàng)建線程對(duì)象，調(diào)用start()方法啟動(dòng)線程

  public class MyRunnable implements Runnable{  //1、自定義線程類(lèi)實(shí)現(xiàn)Runnable接口
      @Override //2、重寫(xiě)run()方法，編寫(xiě)線程執(zhí)行體
      public void run() {
          for (int i = 0; i < 100; i++) {
              System.out.println("run"+i);
          }
      }
      public static void main(String[] args) {
         MyRunnable myRunnable = new MyRunnable();
         //3、創(chuàng)建線程對(duì)象，調(diào)用start()方法啟動(dòng)線程，代理
         new Thread(myRunnable).start();
         for (int i = 0; i < 500; i++) {
             System.out.println("main"+i);
         }
     }
 }

推薦使用實(shí)現(xiàn)Runnable接口，避免單繼承局限性。

方式三：（1）實(shí)現(xiàn)Callable接口，需要返回值類(lèi)型；（2）重寫(xiě)call方法，需要拋出異常；（3)創(chuàng)建目標(biāo)對(duì)象；（4）創(chuàng)建執(zhí)行服務(wù)：ExecutorService s = Executors.newFixedThreadPool(1);

（5）提交執(zhí)行：Future result = s.submit(t);（6）獲取結(jié)果：boolean r = result.get();（7）關(guān)閉服務(wù)：s.shutdownNow();

  public class MyCallable implements Callable<Boolean> { //1、實(shí)現(xiàn)Callable接口，需要返回值類(lèi)型
      @Override //2、重寫(xiě)call方法，需要拋出異常；
      public Boolean call() throws Exception {
          for (int i = 0; i < 100; i++) {
              System.out.println(Thread.currentThread().getName()+":"+i); //獲取當(dāng)前線程名字
          }
          return true;
      }
     public static void main(String[] args) {
         //3、創(chuàng)建目標(biāo)對(duì)象；
         MyCallable m1 = new MyCallable();
         MyCallable m2 = new MyCallable();
         MyCallable m3 = new MyCallable();
         //4、創(chuàng)建執(zhí)行服務(wù)：
         ExecutorService s = Executors.newFixedThreadPool(3);
         //5、提交執(zhí)行：
         Future<Boolean> r1 = s.submit(m1);
         Future<Boolean> r2 = s.submit(m2);
         Future<Boolean> r3 = s.submit(m3);
         //6、獲取結(jié)果：
         try {
             boolean rs1 = r1.get();
             boolean rs2 = r2.get();
             boolean rs3 = r3.get();
         } catch (InterruptedException | ExecutionException e) {
             throw new RuntimeException(e);
         }
         //7關(guān)閉服務(wù)：
         s.shutdownNow();
     }
 }

3、Lambda表達(dá)式 (JDK8)

• 希臘字母表中排序第十一位的字母
• 避免匿名內(nèi)部類(lèi)定義過(guò)多
• 其實(shí)質(zhì)屬于函數(shù)式編程的概念

（params) -> expression[表達(dá)式]

(params) -> statement[語(yǔ)句]

(params) -> {statements}

函數(shù)式接口：任何接口，如果只包含唯一一個(gè)抽象方法，那么它就是一個(gè)函數(shù)式接口。對(duì)于函數(shù)式接口，我們可以通過(guò)lambda表達(dá)式來(lái)創(chuàng)建該接口的對(duì)象。

  public class TestLambda {
      //靜態(tài)內(nèi)部類(lèi)
      static class Like2 implements ILike{
          @Override
          public void like() {
              System.out.println("I like lambda2");
          }
      }
      public static void main(String[] args) {
         //局部?jī)?nèi)部類(lèi)
         class Like3 implements ILike{
             @Override
             public void like() {
                 System.out.println("I like lambda3");
             }
         }
         ILike like = new Like1();
         like.like();
         like = new Like2();
         like.like();
         like = new Like3();
         like.like();
         //匿名內(nèi)部類(lèi)
         like = new ILike() {
             @Override
             public void like() {
                 System.out.println("I like lambda4");
             }
         };
         like.like();
         //lambda表達(dá)式
         //(1)
         like = () -> {
             System.out.println("I like lambda5");
         };
         like.like();
         //（2）花括號(hào)簡(jiǎn)化，只允許有一行代碼,多行必須要用代碼塊
         like = () -> System.out.println("I like lambda6");
         like.like();
         //（3）若帶參數(shù)，可去掉小括號(hào)簡(jiǎn)化，可去掉返回類(lèi)型簡(jiǎn)化
         //like = (int a,int b) -> System.out.println("I like lambda6");
         //like = a,b -> System.out.println("I like lambda6");
     }
 }
 interface ILike{  //函數(shù)式接口
     void like();
 }
 //實(shí)現(xiàn)類(lèi)
 class Like1 implements ILike{
     @Override
     public void like() {
         System.out.println("I like lambda1");
     }
 }

4、線程狀態(tài)

5、停止線程

不推薦使用JDK提供的stop()、destroy()方法。

建議使用一個(gè)標(biāo)志位進(jìn)行終止變量，當(dāng)flag=false，則終止線程運(yùn)行。

  public class TestStop implements Runnable{
      //設(shè)置標(biāo)志位
      private boolean flag = true;
      public static void main(String[] args) {
          TestStop testStop = new TestStop();
          new Thread(testStop).start(); //開(kāi)啟線程
          for (int i = 0; i < 500; i++) {
             if(i == 200){ //當(dāng)主線程跑到200時(shí)，停止run線程
                 testStop.stop();
                 System.out.println("stop run");
             }
             System.out.println("main"+i);
         }
     }
     //提供停止線程的方法，轉(zhuǎn)換標(biāo)志位
     public void stop(){
         this.flag = false;
     }
     @Override
     public void run() {
         int i = 0;
         while (flag){
             System.out.println("run"+ i++);
         }
     }
 }

6、線程休眠 sleep()

• sleep(時(shí)間)指定當(dāng)前線程阻塞的毫秒數(shù)；
• sleep存在異常InterruptedException;
• sleep時(shí)間達(dá)到后線程進(jìn)入就緒狀態(tài)；
• sleep可以模擬網(wǎng)絡(luò)延時(shí)，倒計(jì)時(shí)等；
• 每一個(gè)對(duì)象都有一個(gè)鎖，sleep不會(huì)釋放鎖

7、線程禮讓 yield()

• 禮讓線程，讓當(dāng)前正在執(zhí)行的線程暫停，但不阻塞；
• 將線程從運(yùn)行狀態(tài)轉(zhuǎn)為就緒狀態(tài)
• 讓cpu重新調(diào)度，禮讓不一定成功，看cpu

8、線程強(qiáng)制執(zhí)行 join()

• join合并線程，待此線程執(zhí)行完成后，再執(zhí)行其他線程，其他線程阻塞，就是插隊(duì)

9、線程狀態(tài)觀測(cè)

Thread.State state = thread.getState();

• NEW : 尚未啟動(dòng)的線程處于此狀態(tài)；
• RUNNABLE ：在Java虛擬機(jī)中執(zhí)行的線程處于此狀態(tài)；
• BLOCKED ：被阻塞等待監(jiān)視器鎖定的線程處于此狀態(tài)；
• WAITING ：正在等待另一個(gè)線程執(zhí)行待定動(dòng)作的線程處于此狀態(tài)；
• TIMED_WAITING ：正在等待另一個(gè)線程執(zhí)行動(dòng)作達(dá)到指定等待時(shí)間的線程處于此狀態(tài)；
• TERMINATED ：已退出的線程處于此狀態(tài)

10、線程的優(yōu)先級(jí)

• Java提供一個(gè)線程調(diào)度器來(lái)監(jiān)控程序中啟動(dòng)后進(jìn)入就緒狀態(tài)的所有線程，線程調(diào)度器按照優(yōu)先級(jí)決定應(yīng)該調(diào)度哪個(gè)線程來(lái)執(zhí)行。
• 線程的優(yōu)先級(jí)用數(shù)字表示，范圍從1-10。優(yōu)先級(jí)高的不一定會(huì)先執(zhí)行。優(yōu)先級(jí)的設(shè)定建議在start()調(diào)度前。

1. Thread.MIN_PRIORITY = 1;
2. Thread.MAX_PRIORITY = 10;
3. Thread.NORM_PRIORITY = 5;

• 使用以下方式來(lái)改變或獲取優(yōu)先級(jí)

getPriority().setPriority(int p);

getPriority().getPriority();

 public class TestPriority implements Runnable{
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName()+“–>”+Thread.currentThread().getPriority());
 }
 public static void main(String[] args) {
 //主線程
 System.out.println(Thread.currentThread().getName()+“–>”+Thread.currentThread().getPriority());
 TestPriority testPriority = new TestPriority();
 Thread t1 = new Thread(testPriority);
 Thread t2 = new Thread(testPriority);
 Thread t3 = new Thread(testPriority);
 Thread t4 = new Thread(testPriority);
 t1.setPriority(Thread.MAX_PRIORITY);
 t1.start();
 t2.setPriority(Thread.MIN_PRIORITY);
 t2.start();
 t3.setPriority(8);
 t3.start();
 t4.setPriority(4);
 t4.start();
 }
 }

優(yōu)先級(jí)低只是意味著獲得調(diào)度的概率低，并不是優(yōu)先級(jí)低就不會(huì)被調(diào)用了，要看cpu的調(diào)度。

11、守護(hù)線程 setDaemon()

• 線程分為用戶線程和守護(hù)線程
• 虛擬機(jī)必須確保用戶線程執(zhí)行完畢
• 虛擬機(jī)不用等待守護(hù)線程執(zhí)行完畢
• 如后臺(tái)記錄操作日志，內(nèi)存監(jiān)控，垃圾回收等…

12、線程同步

并發(fā)：同一個(gè)對(duì)象被多個(gè)線程同時(shí)操作。

線程同步：就是一種等待機(jī)制，多個(gè)需要同時(shí)訪問(wèn)此對(duì)象是線程進(jìn)入這個(gè)對(duì)象的等待池形成隊(duì)列，等待前面線程使用完畢，下一個(gè)線程在使用。

形成條件：隊(duì)列 + 鎖

在訪問(wèn)時(shí)加入鎖機(jī)制synchronized，當(dāng)一個(gè)線程獲得對(duì)象的排它鎖，獨(dú)占資源，其他線程必須等待，使用后釋放鎖即可。但也存在一些問(wèn)題：

• 一個(gè)線程持有鎖會(huì)導(dǎo)致其他所有需要此鎖的線程掛起；
• 在多線程競(jìng)爭(zhēng)下，加鎖，釋放鎖會(huì)導(dǎo)致比較多的上下文切換和調(diào)度延時(shí)，引起性能問(wèn)題；
• 如果一個(gè)優(yōu)先級(jí)高的線程等待一個(gè)優(yōu)先級(jí)低的線程釋放鎖，會(huì)導(dǎo)致優(yōu)先級(jí)倒置，引起性能問(wèn)題。

13、同步方法

（1）synchronized關(guān)鍵字包括兩種用法：synchronized方法和synchronized塊。

（2）synchronized方法控制對(duì)“對(duì)象”的訪問(wèn)，每個(gè)對(duì)象對(duì)應(yīng)一把鎖，每個(gè)synchronized方法都必須獲得調(diào)用該方法的對(duì)象的鎖才能執(zhí)行，否則線程會(huì)阻塞，方法一旦執(zhí)行，就獨(dú)占該鎖，直到該方法返回才釋放鎖，后面被阻塞的線程才能獲得這個(gè)鎖，繼續(xù)執(zhí)行。

缺陷：若將一個(gè)大的方法申明為synchronized，將會(huì)影響效率。

  public class SafeBuyTicket{
      public static void main(String[] args) {
          BuyTicket station = new BuyTicket();
          new Thread(station ,"lily").start();
         new Thread(station ,"Ming").start();
          new Thread(station ,"Jenny").start();
      }
  }
 class BuyTicket implements Runnable{
     private int ticketNum = 10;
     boolean flag = true;
     @Override
     public void run() {
         while(flag){
             try {
                 buy();
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
         }
     }
     //同步方法
     private synchronized void buy() throws InterruptedException {
         if(ticketNum <= 0){
             flag = false;
             return;
         }
         Thread.sleep(100);
         System.out.println(Thread.currentThread().getName() + " get " + ticketNum--);
     }
 }

14、同步塊

synchronized(obj){}

obj稱(chēng)之為同步監(jiān)聽(tīng)器：

（1）obj可以是任何對(duì)象，但是推薦使用共享資源作為同步監(jiān)視器

（2）同步方法中無(wú)需指定同步監(jiān)視器，因?yàn)橥椒椒ǖ耐奖O(jiān)視器就是this，就是這個(gè)對(duì)象本身，或者是class。

同步監(jiān)視器的執(zhí)行過(guò)程：

（1）第一個(gè)線程訪問(wèn)，鎖定同步監(jiān)視器，執(zhí)行其中代碼；

（2）第二個(gè)線程訪問(wèn)，發(fā)現(xiàn)同步監(jiān)視器被鎖定，無(wú)法訪問(wèn)；

（3）第一個(gè)線程訪問(wèn)完畢，解鎖同步監(jiān)視器；

（4）第二個(gè)線程訪問(wèn)，發(fā)現(xiàn)同步監(jiān)視器沒(méi)有鎖，然后鎖定并訪問(wèn)；

  public class SafeList {
      public static void main(String[] args) {
          List<String> list = new ArrayList<String>();
          for (int i = 0; i < 1000; i++) {
              new Thread(()->{
                  //代碼塊
                  synchronized (list){
                      list.add(Thread.currentThread().getName());
                  }
             }).start();
         }
         try {
             Thread.sleep(300);
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
         System.out.println(list.size());
     }
 }

CopyOnWriteArrayList是JUC包下的一個(gè)線程安全集合。

15、死鎖

多個(gè)線程各自占有一些共享資源，并且互相等待其他線程占有的資源才能運(yùn)行，而導(dǎo)致兩個(gè)或者多個(gè)線程都在等待對(duì)方釋放的資源，都停止執(zhí)行的情形。某一個(gè)同步塊同時(shí)擁有“兩個(gè)以上對(duì)象的鎖”時(shí)，就可能會(huì)發(fā)生“死鎖”的問(wèn)題。

死鎖避免方法：

• 產(chǎn)生死鎖的四個(gè)必要條件：（破其一可避免死鎖）

（1）互斥條件：一個(gè)資源每次只能被一個(gè)進(jìn)程使用；

（2）請(qǐng)求與保持條件：一個(gè)進(jìn)程因請(qǐng)求資源而阻塞時(shí)，對(duì)已獲得的資源保持不放；

（3）不剝奪條件：進(jìn)程已獲得的資源，在未使用完之前，不能強(qiáng)行剝奪；

（4）循環(huán)等條件：若干進(jìn)程之前形成一種頭尾相接的循環(huán)等待資源關(guān)系。

16、Lock

JDK5.0開(kāi)始，Java提供了更強(qiáng)大的線程同步機(jī)制——通過(guò)顯式定義同步鎖對(duì)象來(lái)實(shí)現(xiàn)同步。同步鎖使用Lock對(duì)象充當(dāng)；

java.util.concurrent.locks.Lock接口是控制多個(gè)線程對(duì)共享資源進(jìn)行訪問(wèn)的工具。鎖提供了對(duì)共享資源的獨(dú)占訪問(wèn)，每次只能有一個(gè)線程對(duì)Lock對(duì)象加鎖，線程開(kāi)始訪問(wèn)共享資源之前應(yīng)先獲得Lock對(duì)象；

ReentrantLock類(lèi)實(shí)現(xiàn)Lock，它擁有與synchronized相同的并發(fā)性和內(nèi)存語(yǔ)義，在實(shí)現(xiàn)線程安全的控制中，比較常用的是ReentrantLock，可以顯式加鎖、釋放鎖。

 class A {
 private final ReentrantLock lock = new ReentrantLock();
 public void m(){
 lock.lock();
 try {
 //保證線程安全的代碼
 }catch (Exception e){
 }finally {
 lock.unlock();
 }
 }
 }

17、Lock與synchronized的對(duì)比

• Lock是顯式鎖（手動(dòng)開(kāi)啟和關(guān)閉鎖),synchronized是隱式鎖，出了作用域自動(dòng)釋放；
• Lock只有代碼塊鎖，synchronized有代碼塊鎖和方法鎖；
• 使用Lock鎖，JVM將花費(fèi)較少的時(shí)間來(lái)調(diào)度線程，性能更好。并且具有更好的擴(kuò)展性；
• 優(yōu)先使用順序：Lock > 同步代碼塊 > 同步方法

18、線程協(xié)作

生產(chǎn)者和消費(fèi)者共享同一個(gè)資源，并且生產(chǎn)者和消費(fèi)者之間相互依賴，互為條件。

• 對(duì)于生產(chǎn)者，沒(méi)有生產(chǎn)產(chǎn)品之前，要通知消費(fèi)者等待，而生產(chǎn)了產(chǎn)品之后，又需要馬上通知消費(fèi)者消費(fèi)；
• 對(duì)于消費(fèi)者，在消費(fèi)之后，要通知生產(chǎn)者已經(jīng)結(jié)束消費(fèi)，需要生產(chǎn)新的產(chǎn)品以供消費(fèi)；
• 在生產(chǎn)者消費(fèi)問(wèn)題中，僅有synchronized是不夠的：synchronized可阻止并發(fā)更新同一個(gè)共享資源，實(shí)現(xiàn)了同步；synchronized不能用來(lái)實(shí)現(xiàn)不同線程之間的消息傳遞（通信）。

Java提供了幾個(gè)方法解決線程之間的通信問(wèn)題：

• wait()：表示線程一直等待，直到其他線程通知，與sleep不同，會(huì)釋放鎖
• wait(long timeout)：指定等待的毫秒數(shù)
• notify()：?jiǎn)拘岩粋€(gè)處于等待狀態(tài)的線程
• notifyAll()：?jiǎn)拘淹粋€(gè)對(duì)象上所有調(diào)用wait()方法的線程，優(yōu)先級(jí)別高的線程優(yōu)先調(diào)度

注意：均是Object類(lèi)的方法，都只能在同步方法或者同步代碼塊中使用，否則會(huì)拋出異常IllegalMonitorStateException.

解決方式1：

并發(fā)協(xié)作模型“生產(chǎn)者/消費(fèi)者模式”—>管程法

（1）生產(chǎn)者：負(fù)責(zé)生產(chǎn)數(shù)據(jù)的模塊（可能是方法，對(duì)象，線程，進(jìn)程）；

（2）消費(fèi)者：負(fù)責(zé)處理數(shù)據(jù)的模塊（可能是方法，對(duì)象，線程，進(jìn)程）；

（3）緩沖區(qū)：消費(fèi)者不能直接使用生產(chǎn)者的數(shù)據(jù)，他們之間有個(gè)“緩沖區(qū)”。

解決方式2：

并發(fā)協(xié)作模型“生產(chǎn)者/消費(fèi)者模式”—>信號(hào)燈法（通過(guò)標(biāo)志位來(lái)實(shí)現(xiàn)）

19、線程池

經(jīng)常創(chuàng)建和銷(xiāo)毀、使用量特別大的資源，比如并發(fā)情況下的線程，對(duì)性能影響很大。解決思路，可以提前創(chuàng)建好多個(gè)線程，放入線程池中，使用時(shí)直接獲取，使用完放回池子中，避免頻繁創(chuàng)建銷(xiāo)毀，實(shí)現(xiàn)重復(fù)利用。這樣能減少創(chuàng)建新線程的時(shí)間，提高響應(yīng)速度；重復(fù)利用線程池中線程，降低資源消耗；便于線程管理等。

• corePoolSize：核心池的大小
• maxnumPoolSize：最大線程數(shù)
• keepAliveTime：線程沒(méi)有任務(wù)時(shí)最多保持多長(zhǎng)時(shí)間后會(huì)終止

JDK5.0起提供了線程池相關(guān)的API：ExecutorService和Executors

ExecutorService：真正的線程池接口。常見(jiàn)子類(lèi)ThreadPoolExecutor

• void execute(Runnable command)：執(zhí)行任務(wù)/命令，沒(méi)有返回值，一般用來(lái)執(zhí)行Runnable
• Future submit(Callable task)：執(zhí)行任務(wù)，有返回值，一般又來(lái)執(zhí)行Callable
• void shutdown()：關(guān)閉連接池

Executors：工具類(lèi)、線程池的工廠類(lèi)，用于創(chuàng)建并返回不同類(lèi)型的線程池。

  public class TestPool {
      public static void main(String[] args) {
          //創(chuàng)建服務(wù)，創(chuàng)建線程池
          ExecutorService service = Executors.newFixedThreadPool(10);
          //執(zhí)行
          service.execute(new MyThread());
          service.execute(new MyThread());
          service.execute(new MyThread());
         service.execute(new MyThread());
         //關(guān)閉連接
         service.shutdown();
     }
 }
 class MyThread implements Runnable{
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName());
     }
 }

到此這篇關(guān)于Java進(jìn)階之多線程的文章就介紹到這了,更多相關(guān)java多線程內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論