国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

1、多線程 2、線程池

cnTomato / 370人閱讀

摘要:一個進程中是可以有多個線程的,這個應用程序也可以稱之為多線程程序。也就是說線程創建并執行需要給定線程要執行的任務。接口對線程對象和線程任務進行解耦。另外,通過適當的調整線程中的線程數目可以防止出現資源不足的情況。

01進程概念

*A:進程概念
*a:進程:進程指正在運行的程序。確切的來說,當一個程序進入內存運行,

    即變成一個進程,進程是處于運行過程中的程序,并且具有一定獨立功能。
02線程的概念

*A:線程的概念
*a:線程:線程是進程中的一個執行單元(執行路徑),負責當前進程中程序的執行,

      一個進程中至少有一個線程。一個進程中是可以有多個線程的,
      這個應用程序也可以稱之為多線程程序。
簡而言之:一個程序運行后至少有一個進程,一個進程中可以包含多個線程
03深入線程的概念

A:深入線程的概念

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

單線程程序:即,若有多個任務只能依次執行。當上一個任務執行結束后,下一個任務開始執行。如去            網吧上網,網吧只能讓一個人上網,當這個人下機后,下一個人才能上網。
多線程程序:即,若有多個任務可以同時執行。如,去網吧上網,網吧能夠讓多個人同時上網。
04迅雷的多線程下載

A:迅雷的多線程下載

 多線程,每個線程都讀一個文件
05線程的運行模式

A:線程的運行模式

a:分時調度
  所有線程輪流使用 CPU 的使用權,平均分配每個線程占用 CPU 的時間。

b:搶占式調度
 優先讓優先級高的線程使用 CPU,如果線程的優先級相同,那么會隨機選擇一個(線程隨機性),Java使用的為搶占式調度。

 大部分操作系統都支持多進程并發運行,現在的操作系統幾乎都支持同時運行多個程序。比如:現在我們上課一邊使用編輯器,一邊使用錄屏軟件,同時還開著畫圖板,dos窗口等軟件。此時,這些程序是在同時運行,”感覺這些軟件好像在同一時刻運行著“。

 實際上,CPU(中央處理器)使用搶占式調度模式在多個線程間進行著高速的切換。對于CPU的一個核而言,某個時刻,只能執行一個線程,而 CPU的在多個線程間切換速度相對我們的感覺要快,看上去就是在同一時刻運行。
 其實,多線程程序并不能提高程序的運行速度,但能夠提高程序運行效率,讓CPU的使用率更高。
06main的主線程

*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);
    }
  }
}

=======================第二節課開始=============================================

07Thread類介紹

A:Thread類介紹:Thread是程序中的執行線程。Java 虛擬機允許應用程序并發地運行多個執行線程。

 發現創建新執行線程有兩種方法。
 ?a:一種方法是將類聲明為 Thread 的子類。該子類應重寫 Thread 類的 run 方法。創建對象,開啟線程。run方法相當于其他線程的main方法。
 ?b:另一種方法是聲明一個實現 Runnable 接口的類。該類然后實現 run 方法。然后創建Runnable的子類對象,傳入到某個線程的構造方法中,開啟線程。
08實現線程程序繼承Thread

*A:實現線程程序繼承Thread

    /*
   * 創建和啟動一個線程
   *   創建Thread子類對象
   *   子類對象調用方法start()
   *      讓線程程序執行,JVM調用線程中的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);
      }
    }
  }

 
09線程執行的隨機性

*A:線程執行的隨機性

/*
  代碼分析:
     整個程序就只有三個線程,
     一個是主線程
       啟動另外兩個線程
        st.start();
        st1.start();
        for(int i = 0; i < 50;i++){
          System.out.println("main..."+i);
        }
     一個是st(Thread-0)線程
     for(int i = 0; i < 50;i++){
       System.out.println("run..."+i);
     }
     一個是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);
     }
   }
 }
10為什么要繼承Thread

*A:什么要繼承Thread

a:我們為什么要繼承Thread類,并調用其的start方法才能開啟線程呢?
   繼承Thread類:因為Thread類用來描述線程,具備線程應該有功能。那為什么不直接創建Thread類的對象呢?
   如下代碼:
    Thread t1 = new Thread();
    t1.start();//這樣做沒有錯,但是該start調用的是Thread類中的run方法
              //而這個run方法沒有做什么事情,更重要的是這個run方法中并沒有定義我們需要讓線程執行的代碼。

b:創建線程的目的是什么?
 是為了建立程序多帶帶的執行路徑,讓多部分代碼實現同時執行。也就是說線程創建并執行需要給定線程要執行的任務。
 對于之前所講的主線程,它的任務定義在main函數中。自定義線程需要執行的任務都定義在run方法中。
11多線程內存圖解

*A:多線程內存圖解

  多線程執行時,到底在內存中是如何運行的呢?
    多線程執行時,在棧內存中,其實每一個執行線程都有一片自己所屬的棧內存空間。進行方法的壓棧和彈棧。
    當執行線程的任務結束了,線程自動在棧內存中釋放了。但是當所有的執行線程都結束了,那么進程就結束了。

=======================第三節課開始=============================================

12獲取線程名字Thread類方法getName

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

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

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

  }
}
13獲取線程名字Thread類方法currentThread

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

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

public class NameThread extends Thread{

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

}

/*

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

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());
 }

}

14線程名字設置

A:線程名字設置

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

    }
  }
15Thread類方法sleep

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切換到該線程繼續向下執行
      }catch(Exception ex){
        
      }
      System.out.println(i);
    }
  }
 }
16實現線程的另一種方式實現Runnable接口

A:實現線程的另一種方式實現Runnable接口

   /*
  *  實現接口方式的線程
  *    創建Thread類對象,構造方法中,傳遞Runnable接口實現類
  *    調用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);
    }
  }
 }

 /*
  *  實現線程成功的另一個方式,接口實現
  *  實現接口Runnable,重寫run方法
  */
 public class SubRunnable implements Runnable{
  public void run(){
    for(int i = 0 ; i < 50; i++){
      System.out.println("run..."+i);
    }
  }
 }
17實現接口方式的好處
A:實現接口方式的好處
 第二種方式實現Runnable接口避免了單繼承的局限性,所以較為常用。
 實現Runnable接口的方式,更加的符合面向對象,線程分為兩部分,一部分線程對象,一部分線程任務。
 繼承Thread類,線程對象和線程任務耦合在一起。
 一旦創建Thread類的子類對象,既是線程對象,有又有線程任務。
 實現runnable接口,將線程任務多帶帶分離出來封裝成對象,類型就是Runnable接口類型。Runnable接口對線程對象和線程任務進行解耦。
 (降低緊密性或者依賴性,創建線程和執行任務不綁定)
18匿名內部類實現線程程序
*A:匿名內部類實現線程程序 
/*
 *  使用匿名內部類,實現多線程程序
 *  前提: 繼承或者接口實現
 *  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();
    
    //實現接口方式  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();
    
  }
}

=======================第四節課開始=============================================

19線程的狀態圖

A:線程的狀態圖

    a:參見線程狀態圖.jpg
20線程池的原理

A:線程池的原理

  1.在java中,如果每個請求到達就創建一個新線程,開銷是相當大的。
  2.在實際使用中,創建和銷毀線程花費的時間和消耗的系統資源都相當大,甚至可能要比在處理實際的用戶請求的時間和資源要多的多。
  3.除了創建和銷毀線程的開銷之外,活動的線程也需要消耗系統資源。
    如果在一個jvm里創建太多的線程,可能會使系統由于過度消耗內存或“切換過度”而導致系統資源不足。
    為了防止資源不足,需要采取一些辦法來限制任何給定時刻處理的請求數目,盡可能減少創建和銷毀線程的次數,特別是一些資源耗費比較大的線程的創建和銷毀,盡量利用已有對象來進行服務。
  線程池主要用來解決線程生命周期開銷問題和資源不足問題。通過對多個任務重復使用線程,線程創建的開銷就被分攤到了多個任務上了,而且由于在請求到達時線程已經存在,所以消除了線程創建所帶來的延遲。這樣,就可以立即為請求服務,使用應用程序響應更快。另外,通過適當的調整線程中的線程數目可以防止出現資源不足的情況。
21JDK5實現線程池
A:JDK5實現線程池
    /*
   *  JDK1.5新特性,實現線程池程序
   *  使用工廠類 Executors中的靜態方法創建線程對象,指定線程的個數
   *   static ExecutorService newFixedThreadPool(int 個數) 返回線程池對象
   *   返回的是ExecutorService接口的實現類 (線程池對象)
   *   
   *   接口實現類對象,調用方法submit (Ruunable r) 提交線程執行任務
   *          
   */
  public class ThreadPoolDemo {
    public static void main(String[] args) {
      //調用工廠類的靜態方法,創建線程池對象
      //返回線程池對象,是返回的接口
      ExecutorService es = Executors.newFixedThreadPool(2);
        //調用接口實現類對象es中的方法submit提交線程任務
      //將Runnable接口實現類對象,傳遞
      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()+" 線程提交任務");
    }
  }
22實現線程的Callable接口方式

A:實現線程的Callable接口方式

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

 import java.util.concurrent.Callable;

 public class ThreadPoolCallable implements Callable{
  public String call(){
    return "abc";
  }
 }
23線程實現異步計算

A:線程實現異步計算

/*
 * 使用多線程技術,求和
 * 兩個線程,1個線程計算1+100,另一個線程計算1+200的和
 * 多線程的異步計算
 */
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;
  }
}

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/67185.html

相關文章

  • 線程學習筆記(3):線程

    摘要:線程池維護線程所允許的空閑時間的單位線程池所使用的緩沖隊列一般采用阻塞隊列,有很多種無界阻塞隊列有界阻塞隊列同步移交隊列線程池對拒絕任務的處理策略丟棄任務并拋出異常。 一、線程池的概念 池,就是一個工廠,會提前生產出一些東西供使用。所以線程池就是處理多線程的一種方式。其作用就在于:復用已有資源,控制資源總量 二、為什么使用線程池 如果不使用線程池,那么:(1)使用單線程,但是這種方式吞...

    Blackjun 評論0 收藏0
  • Java線程從使用到閱讀源碼(3/10)

    摘要:最后,我們會通過對源代碼的剖析深入了解線程池的運行過程和具體設計,真正達到知其然而知其所以然的水平。創建線程池既然線程池是一個類,那么最直接的使用方法一定是一個類的對象,例如。單線程線程池單線程線程 我們一般不會選擇直接使用線程類Thread進行多線程編程,而是使用更方便的線程池來進行任務的調度和管理。線程池就像共享單車,我們只要在我們有需要的時候去獲取就可以了。甚至可以說線程池更棒,...

    468122151 評論0 收藏0
  • Java線程2):使用線程 ThreadPoolExecutor

    摘要:本文只介紹中線程池的基本使用,不會過多的涉及到線程池的原理。可緩存線程的線程池創建一個可緩存線程的線程池。首先是從接口繼承到的方法使用該方法即將一個任務交給線程池去執行。方法方法的作用是向線程池發送關閉的指令。 首先,我們為什么需要線程池?讓我們先來了解下什么是 對象池 技術。某些對象(比如線程,數據庫連接等),它們創建的代價是非常大的 —— 相比于一般對象,它們創建消耗的時間和內存都...

    darry 評論0 收藏0
  • jave 線程

    摘要:在開發過程中,合理地使用線程池能夠帶來個好處。性質不同的任務可以交給不同規模的線程池執行。當然具體合理線程池值大小,需要結合系統實際情況,在大量的嘗試下比較才能得出,以上只是前人總結的規律。 線程池簡述 Java中的線程池是運用場景最多的并發框架,幾乎所有需要異步或并發執行任務的程序都可以使用線程池。在開發過程中,合理地使用線程池能夠帶來3個好處。 降低資源消耗。通過重復利用已創建的...

    kgbook 評論0 收藏0
  • Java線程的工作原理,好處和注意事項

    摘要:線程池的工作原理一個線程池管理了一組工作線程,同時它還包括了一個用于放置等待執行任務的任務隊列阻塞隊列。使用線程池可以對線程進行統一的分配和監控。線程池的注意事項雖然線程池是構建多線程應用程序的強大機制,但使用它并不是沒有風險的。 線程池的工作原理一個線程池管理了一組工作線程, 同時它還包括了一個用于放置等待執行 任務的任務隊列(阻塞隊列) 。 一個線程池管理了一組工作線程, 同時它還...

    ZweiZhao 評論0 收藏0
  • Java 線程并發編程面試筆錄一覽

    摘要:創建線程的方式方式一將類聲明為的子類。將該線程標記為守護線程或用戶線程。其中方法隱含的線程為父線程。恢復線程,已過時。等待該線程銷毀終止。更多的使當前線程在鎖存器倒計數至零之前一直等待,除非線 知識體系圖: showImg(https://segmentfault.com/img/bVbef6v?w=1280&h=960); 1、線程是什么? 線程是進程中獨立運行的子任務。 2、創建線...

    bitkylin 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<