摘要：一個(gè)進(jìn)程中是可以有多個(gè)線程的，這個(gè)應(yīng)用程序也可以稱之為多線程程序。也就是說線程創(chuàng)建并執(zhí)行需要給定線程要執(zhí)行的任務(wù)。接口對線程對象和線程任務(wù)進(jìn)行解耦。另外，通過適當(dāng)?shù)恼{(diào)整線程中的線程數(shù)目可以防止出現(xiàn)資源不足的情況。

*A:進(jìn)程概念
*a:進(jìn)程：進(jìn)程指正在運(yùn)行的程序。確切的來說，當(dāng)一個(gè)程序進(jìn)入內(nèi)存運(yùn)行，

    即變成一個(gè)進(jìn)程，進(jìn)程是處于運(yùn)行過程中的程序，并且具有一定獨(dú)立功能。

*A:線程的概念
*a:線程：線程是進(jìn)程中的一個(gè)執(zhí)行單元(執(zhí)行路徑)，負(fù)責(zé)當(dāng)前進(jìn)程中程序的執(zhí)行，

      一個(gè)進(jìn)程中至少有一個(gè)線程。一個(gè)進(jìn)程中是可以有多個(gè)線程的，
      這個(gè)應(yīng)用程序也可以稱之為多線程程序。
簡而言之：一個(gè)程序運(yùn)行后至少有一個(gè)進(jìn)程，一個(gè)進(jìn)程中可以包含多個(gè)線程

A:深入線程的概念

什么是多線程呢？
 即就是一個(gè)程序中有多個(gè)線程在同時(shí)執(zhí)行。
 一個(gè)核心的CPU在多個(gè)線程之間進(jìn)行著隨即切換動作,由于切換時(shí)間很短(毫秒甚至是納秒級別),導(dǎo)致我們感覺不出來

單線程程序：即，若有多個(gè)任務(wù)只能依次執(zhí)行。當(dāng)上一個(gè)任務(wù)執(zhí)行結(jié)束后，下一個(gè)任務(wù)開始執(zhí)行。如去            網(wǎng)吧上網(wǎng)，網(wǎng)吧只能讓一個(gè)人上網(wǎng)，當(dāng)這個(gè)人下機(jī)后，下一個(gè)人才能上網(wǎng)。
多線程程序：即，若有多個(gè)任務(wù)可以同時(shí)執(zhí)行。如，去網(wǎng)吧上網(wǎng)，網(wǎng)吧能夠讓多個(gè)人同時(shí)上網(wǎng)。

A:迅雷的多線程下載

 多線程,每個(gè)線程都讀一個(gè)文件

A:線程的運(yùn)行模式

a:分時(shí)調(diào)度
  所有線程輪流使用 CPU 的使用權(quán)，平均分配每個(gè)線程占用 CPU 的時(shí)間。

b:搶占式調(diào)度
 優(yōu)先讓優(yōu)先級高的線程使用 CPU，如果線程的優(yōu)先級相同，那么會隨機(jī)選擇一個(gè)(線程隨機(jī)性)，Java使用的為搶占式調(diào)度。

 大部分操作系統(tǒng)都支持多進(jìn)程并發(fā)運(yùn)行，現(xiàn)在的操作系統(tǒng)幾乎都支持同時(shí)運(yùn)行多個(gè)程序。比如：現(xiàn)在我們上課一邊使用編輯器，一邊使用錄屏軟件，同時(shí)還開著畫圖板，dos窗口等軟件。此時(shí)，這些程序是在同時(shí)運(yùn)行，”感覺這些軟件好像在同一時(shí)刻運(yùn)行著“。

 實(shí)際上，CPU(中央處理器)使用搶占式調(diào)度模式在多個(gè)線程間進(jìn)行著高速的切換。對于CPU的一個(gè)核而言，某個(gè)時(shí)刻，只能執(zhí)行一個(gè)線程，而 CPU的在多個(gè)線程間切換速度相對我們的感覺要快，看上去就是在同一時(shí)刻運(yùn)行。
 其實(shí)，多線程程序并不能提高程序的運(yùn)行速度，但能夠提高程序運(yùn)行效率，讓CPU的使用率更高。

*A:main的主線程

/*
 *  程序中的主線程
 */
public class Demo {
  public static void main(String[] args) {
    System.out.println(0/0);
    function();
    System.out.println(Math.abs(-9));
  }
  
  public static void function(){
    for(int i = 0 ; i < 10000;i++){
      System.out.println(i);
    }
  }
}

=======================第二節(jié)課開始=============================================

A:Thread類介紹:Thread是程序中的執(zhí)行線程。Java 虛擬機(jī)允許應(yīng)用程序并發(fā)地運(yùn)行多個(gè)執(zhí)行線程。

 發(fā)現(xiàn)創(chuàng)建新執(zhí)行線程有兩種方法。
 ?a:一種方法是將類聲明為 Thread 的子類。該子類應(yīng)重寫 Thread 類的 run 方法。創(chuàng)建對象，開啟線程。run方法相當(dāng)于其他線程的main方法。
 ?b:另一種方法是聲明一個(gè)實(shí)現(xiàn) Runnable 接口的類。該類然后實(shí)現(xiàn) run 方法。然后創(chuàng)建Runnable的子類對象，傳入到某個(gè)線程的構(gòu)造方法中，開啟線程。

*A:實(shí)現(xiàn)線程程序繼承Thread

    /*
   * 創(chuàng)建和啟動一個(gè)線程
   *   創(chuàng)建Thread子類對象
   *   子類對象調(diào)用方法start()
   *      讓線程程序執(zhí)行,JVM調(diào)用線程中的run
   */
  public class ThreadDemo {
    public static void main(String[] args) {
      SubThread st = new SubThread();
      SubThread st1 = new SubThread();
      st.start();
      st1.start();
      for(int i = 0; i < 50;i++){
        System.out.println("main..."+i);
      }
    }
  }
  /*
   *  定義子類,繼承Thread 
   *  重寫方法run 
   */
  public class SubThread  extends Thread{
    public void run(){
      for(int i = 0; i < 50;i++){
        System.out.println("run..."+i);
      }
    }
  }

 

*A:線程執(zhí)行的隨機(jī)性

/*
  代碼分析:
     整個(gè)程序就只有三個(gè)線程,
     一個(gè)是主線程
       啟動另外兩個(gè)線程
        st.start();
        st1.start();
        for(int i = 0; i < 50;i++){
          System.out.println("main..."+i);
        }
     一個(gè)是st(Thread-0)線程
     for(int i = 0; i < 50;i++){
       System.out.println("run..."+i);
     }
     一個(gè)是st1(Thread-1)線程下 

*/
 public class ThreadDemo {
   public static void main(String[] args) {
     SubThread st = new SubThread();
     SubThread st1 = new SubThread();
     st.start();
     st1.start();
     for(int i = 0; i < 50;i++){
       System.out.println("main..."+i);
     }
   }
 }
 /*
  *  定義子類,繼承Thread 
  *  重寫方法run 
  */
 public class SubThread  extends Thread{
   public void run(){
     for(int i = 0; i < 50;i++){
       System.out.println("run..."+i);
     }
   }
 }

*A:什么要繼承Thread

a:我們?yōu)槭裁匆^承Thread類，并調(diào)用其的start方法才能開啟線程呢？
   繼承Thread類：因?yàn)門hread類用來描述線程，具備線程應(yīng)該有功能。那為什么不直接創(chuàng)建Thread類的對象呢？
   如下代碼：
    Thread t1 = new Thread();
    t1.start();//這樣做沒有錯(cuò)，但是該start調(diào)用的是Thread類中的run方法
              //而這個(gè)run方法沒有做什么事情，更重要的是這個(gè)run方法中并沒有定義我們需要讓線程執(zhí)行的代碼。

b:創(chuàng)建線程的目的是什么？
 是為了建立程序多帶帶的執(zhí)行路徑，讓多部分代碼實(shí)現(xiàn)同時(shí)執(zhí)行。也就是說線程創(chuàng)建并執(zhí)行需要給定線程要執(zhí)行的任務(wù)。
 對于之前所講的主線程，它的任務(wù)定義在main函數(shù)中。自定義線程需要執(zhí)行的任務(wù)都定義在run方法中。

*A:多線程內(nèi)存圖解

  多線程執(zhí)行時(shí)，到底在內(nèi)存中是如何運(yùn)行的呢？
    多線程執(zhí)行時(shí)，在棧內(nèi)存中，其實(shí)每一個(gè)執(zhí)行線程都有一片自己所屬的棧內(nèi)存空間。進(jìn)行方法的壓棧和彈棧。
    當(dāng)執(zhí)行線程的任務(wù)結(jié)束了，線程自動在棧內(nèi)存中釋放了。但是當(dāng)所有的執(zhí)行線程都結(jié)束了，那么進(jìn)程就結(jié)束了。

=======================第三節(jié)課開始=============================================

*A:獲取線程名字Thread類方法getName

/*
 *  獲取線程名字,父類Thread方法
 *    String getName()
 */
public class NameThread extends Thread{
  
  public NameThread(){
    super("小強(qiáng)");
  }
  
  public void run(){
    System.out.println(getName());
  }
}

/*
 *  每個(gè)線程,都有自己的名字
 *  運(yùn)行方法main線程,名字就是"main"
 *  其他新鍵的線程也有名字,默認(rèn) "Thread-0","Thread-1"
 *  
 *  JVM開啟主線程,運(yùn)行方法main,主線程也是線程,是線程必然就是
 *  Thread類對象
 */
public class ThreadDemo {
  public static void main(String[] args) {
    NameThread nt = new NameThread();
    nt.start();
    
     

  }
}

*A:獲取線程名字Thread類方法currentThread
/*

*  獲取線程名字,父類Thread方法
*    String getName()
*/

public class NameThread extends Thread{

 public void run(){
   System.out.println(getName());
 }

}

/*

*  每個(gè)線程,都有自己的名字
*  運(yùn)行方法main線程,名字就是"main"
*  其他新鍵的線程也有名字,默認(rèn) "Thread-0","Thread-1"
*  
*  JVM開啟主線程,運(yùn)行方法main,主線程也是線程,是線程必然就是
*  Thread類對象
*  Thread類中,靜態(tài)方法
*   static Thread currentThread()返回正在執(zhí)行的線程對象
*/

public class ThreadDemo {

 public static void main(String[] args) {
   NameThread nt = new NameThread();
   nt.start();
   
   /*Thread t =Thread.currentThread();
   System.out.println(t.getName());*/
   System.out.println(Thread.currentThread().getName());

 }

}

A:線程名字設(shè)置

  /*
   *  獲取線程名字,父類Thread方法
   *    String getName()
   */
  public class NameThread extends Thread{
    
    public NameThread(){
      super("小強(qiáng)");
    }
    
    public void run(){
      System.out.println(getName());
    }
  }
  
  /*
   *  每個(gè)線程,都有自己的名字
   *  運(yùn)行方法main線程,名字就是"main"
   *  其他新鍵的線程也有名字,默認(rèn) "Thread-0","Thread-1"
   *  
   *  JVM開啟主線程,運(yùn)行方法main,主線程也是線程,是線程必然就是
   *  Thread類對象
   *  Thread類中,靜態(tài)方法
   *   static Thread currentThread()返回正在執(zhí)行的線程對象
   */
  public class ThreadDemo {
    public static void main(String[] args) {
      NameThread nt = new NameThread();
      nt.setName("旺財(cái)");
      nt.start();

    }
  }

A:Thread類方法sleep

 public class ThreadDemo {
  public static void main(String[] args) throws Exception{
    /*for(int i = 0 ; i < 5 ;i++){
      Thread.sleep(50);
      System.out.println(i);
    }*/
    
    new SleepThread().start();
  }
 }
 
 public class SleepThread extends Thread{
  public void run(){
    for(int i = 0 ; i < 5 ;i++){
      try{
        Thread.sleep(500);//睡眠500ms,500ms已到并且cpu切換到該線程繼續(xù)向下執(zhí)行
      }catch(Exception ex){
        
      }
      System.out.println(i);
    }
  }
 }

A:實(shí)現(xiàn)線程的另一種方式實(shí)現(xiàn)Runnable接口

   /*
  *  實(shí)現(xiàn)接口方式的線程
  *    創(chuàng)建Thread類對象,構(gòu)造方法中,傳遞Runnable接口實(shí)現(xiàn)類
  *    調(diào)用Thread類方法start()
  */
 public class ThreadDemo {
  public static void main(String[] args) {
    SubRunnable sr = new SubRunnable();
    Thread t = new Thread(sr);
    t.start();
    for(int i = 0 ; i < 50; i++){
      System.out.println("main..."+i);
    }
  }
 }

 /*
  *  實(shí)現(xiàn)線程成功的另一個(gè)方式,接口實(shí)現(xiàn)
  *  實(shí)現(xiàn)接口Runnable,重寫run方法
  */
 public class SubRunnable implements Runnable{
  public void run(){
    for(int i = 0 ; i < 50; i++){
      System.out.println("run..."+i);
    }
  }
 }

A:實(shí)現(xiàn)接口方式的好處
 第二種方式實(shí)現(xiàn)Runnable接口避免了單繼承的局限性，所以較為常用。
 實(shí)現(xiàn)Runnable接口的方式，更加的符合面向?qū)ο?，線程分為兩部分，一部分線程對象，一部分線程任務(wù)。
 繼承Thread類，線程對象和線程任務(wù)耦合在一起。
 一旦創(chuàng)建Thread類的子類對象，既是線程對象，有又有線程任務(wù)。
 實(shí)現(xiàn)runnable接口，將線程任務(wù)多帶帶分離出來封裝成對象，類型就是Runnable接口類型。Runnable接口對線程對象和線程任務(wù)進(jìn)行解耦。
 (降低緊密性或者依賴性,創(chuàng)建線程和執(zhí)行任務(wù)不綁定)

*A:匿名內(nèi)部類實(shí)現(xiàn)線程程序 
/*
 *  使用匿名內(nèi)部類,實(shí)現(xiàn)多線程程序
 *  前提: 繼承或者接口實(shí)現(xiàn)
 *  new 父類或者接口(){
 *     重寫抽象方法
 *  }
 */
public class ThreadDemo {
  public static void main(String[] args) {
    //繼承方式  XXX extends Thread{ public void run(){}}
    new Thread(){
      public void run(){
        System.out.println("!!!");
      }
    }.start();
    
    //實(shí)現(xiàn)接口方式  XXX implements Runnable{ public void run(){}}
    
    Runnable r = new Runnable(){
      public void run(){
        System.out.println("###");
      }
    };
    new Thread(r).start();
    
    
    new Thread(new Runnable(){
      public void run(){
        System.out.println("@@@");
      }
    }).start();
    
  }
}

=======================第四節(jié)課開始=============================================

A:線程的狀態(tài)圖

    a:參見線程狀態(tài)圖.jpg

A:線程池的原理

  1.在java中，如果每個(gè)請求到達(dá)就創(chuàng)建一個(gè)新線程，開銷是相當(dāng)大的。
  2.在實(shí)際使用中，創(chuàng)建和銷毀線程花費(fèi)的時(shí)間和消耗的系統(tǒng)資源都相當(dāng)大，甚至可能要比在處理實(shí)際的用戶請求的時(shí)間和資源要多的多。
  3.除了創(chuàng)建和銷毀線程的開銷之外，活動的線程也需要消耗系統(tǒng)資源。
    如果在一個(gè)jvm里創(chuàng)建太多的線程，可能會使系統(tǒng)由于過度消耗內(nèi)存或“切換過度”而導(dǎo)致系統(tǒng)資源不足。
    為了防止資源不足，需要采取一些辦法來限制任何給定時(shí)刻處理的請求數(shù)目，盡可能減少創(chuàng)建和銷毀線程的次數(shù)，特別是一些資源耗費(fèi)比較大的線程的創(chuàng)建和銷毀，盡量利用已有對象來進(jìn)行服務(wù)。
  線程池主要用來解決線程生命周期開銷問題和資源不足問題。通過對多個(gè)任務(wù)重復(fù)使用線程，線程創(chuàng)建的開銷就被分?jǐn)偟搅硕鄠€(gè)任務(wù)上了，而且由于在請求到達(dá)時(shí)線程已經(jīng)存在，所以消除了線程創(chuàng)建所帶來的延遲。這樣，就可以立即為請求服務(wù)，使用應(yīng)用程序響應(yīng)更快。另外，通過適當(dāng)?shù)恼{(diào)整線程中的線程數(shù)目可以防止出現(xiàn)資源不足的情況。

A:JDK5實(shí)現(xiàn)線程池
    /*
   *  JDK1.5新特性,實(shí)現(xiàn)線程池程序
   *  使用工廠類 Executors中的靜態(tài)方法創(chuàng)建線程對象,指定線程的個(gè)數(shù)
   *   static ExecutorService newFixedThreadPool(int 個(gè)數(shù)) 返回線程池對象
   *   返回的是ExecutorService接口的實(shí)現(xiàn)類 (線程池對象)
   *   
   *   接口實(shí)現(xiàn)類對象,調(diào)用方法submit (Ruunable r) 提交線程執(zhí)行任務(wù)
   *          
   */
  public class ThreadPoolDemo {
    public static void main(String[] args) {
      //調(diào)用工廠類的靜態(tài)方法,創(chuàng)建線程池對象
      //返回線程池對象,是返回的接口
      ExecutorService es = Executors.newFixedThreadPool(2);
        //調(diào)用接口實(shí)現(xiàn)類對象es中的方法submit提交線程任務(wù)
      //將Runnable接口實(shí)現(xiàn)類對象,傳遞
      es.submit(new ThreadPoolRunnable());
      es.submit(new ThreadPoolRunnable());
      es.submit(new ThreadPoolRunnable());
    
    }
  }

  public class ThreadPoolRunnable implements Runnable {
    public void run(){
      System.out.println(Thread.currentThread().getName()+" 線程提交任務(wù)");
    }
  }

A:實(shí)現(xiàn)線程的Callable接口方式

 /*
  *  實(shí)現(xiàn)線程程序的第三個(gè)方式,實(shí)現(xiàn)Callable接口方式
  *  實(shí)現(xiàn)步驟
  *    工廠類 Executors靜態(tài)方法newFixedThreadPool方法,創(chuàng)建線程池對象
  *    線程池對象ExecutorService接口實(shí)現(xiàn)類,調(diào)用方法submit提交線程任務(wù)
  *    submit(Callable c)
  */
 public class ThreadPoolDemo1 {
  public static void main(String[] args)throws Exception {
    ExecutorService es = Executors.newFixedThreadPool(2);
    //提交線程任務(wù)的方法submit方法返回 Future接口的實(shí)現(xiàn)類
    Future f = es.submit(new ThreadPoolCallable());
    String s = f.get();
    System.out.println(s);
  }
 }
 /*
  * Callable 接口的實(shí)現(xiàn)類,作為線程提交任務(wù)出現(xiàn)
  * 使用方法返回值
  */

 import java.util.concurrent.Callable;

 public class ThreadPoolCallable implements Callable{
  public String call(){
    return "abc";
  }
 }

A:線程實(shí)現(xiàn)異步計(jì)算

/*
 * 使用多線程技術(shù),求和
 * 兩個(gè)線程,1個(gè)線程計(jì)算1+100,另一個(gè)線程計(jì)算1+200的和
 * 多線程的異步計(jì)算
 */
public class ThreadPoolDemo {
  public static void main(String[] args)throws Exception {
    ExecutorService es = Executors.newFixedThreadPool(2);
    Future f1 =es.submit(new GetSumCallable(100));
    Future f2 =es.submit(new GetSumCallable(200));
    System.out.println(f1.get());
    System.out.println(f2.get());
    es.shutdown();
  }
}

 

public class GetSumCallable implements Callable{
  private int a;
  public GetSumCallable(int a){
    this.a=a;
  }
  
  public Integer call(){
    int sum = 0 ;
    for(int i = 1 ; i <=a ; i++){
      sum = sum + i ;
    }
    return sum;
  }
}