2. 程式人生 > >多執行緒+JAVA學習筆記-DAY24

多執行緒+JAVA學習筆記-DAY24

阿新 • • 發佈：2018-11-04

24.01_多執行緒(多執行緒的引入)(瞭解)

  • 1.什麼是執行緒
    • 執行緒是程式執行的一條路徑, 一個程序中可以包含多條執行緒
    • 多執行緒併發執行可以提高程式的效率, 可以同時完成多項工作
  • 2.多執行緒的應用場景
    • 紅蜘蛛同時共享螢幕給多個電腦
    • 迅雷開啟多條執行緒一起下載
    • QQ同時和多個人一起視訊
    • 伺服器同時處理多個客戶端請求

24.02_多執行緒(多執行緒並行和併發的區別)(瞭解)

  • 並行就是兩個任務同時執行，就是甲任務進行的同時，乙任務也在進行。(需要多核CPU)
  • 併發是指兩個任務都請求執行，而處理器只能按受一個任務，就把這兩個任務安排輪流進行，由於時間間隔較短，使人感覺兩個任務都在執行。
  • 比如我跟兩個網友聊天，左手操作一個電腦跟甲聊，同時右手用另一臺電腦跟乙聊天，這就叫並行。
  • 如果用一臺電腦我先給甲發個訊息，然後立刻再給乙發訊息，然後再跟甲聊，再跟乙聊。這就叫併發。

24.03_多執行緒(Java程式執行原理和JVM的啟動是多執行緒的嗎)(瞭解)

  • A:Java程式執行原理

    • Java命令會啟動java虛擬機器，啟動JVM，等於啟動了一個應用程式，也就是啟動了一個程序。該程序會自動啟動一個 “主執行緒” ，然後主執行緒去呼叫某個類的 main 方法。

  • B:JVM的啟動是多執行緒的嗎

    • JVM啟動至少啟動了垃圾回收執行緒和主執行緒，所以是多執行緒的。

      public class Demo1_Thread {

    /**
     * @param args
     * 證明jvm是多執行緒的
     */
    public static void main(String[] args) {
        for(int i = 0; i < 100000; i++) {
            new Demo();
        }

        for(int i = 0; i < 10000; i++) {
            System.out.println("我是主執行緒的執行程式碼");
        }
    }

}

class Demo {

    @Override
    public void finalize() {
        System.out.println("垃圾被清掃了");
    }

}

24.04_多執行緒(多執行緒程式實現的方式1)(掌握)

  • 1.繼承Thread

    • 定義類繼承Thread
    • 重寫run方法
    • 把新執行緒要做的事寫在run方法中
    • 建立執行緒物件
    • 開啟新執行緒, 內部會自動執行run方法
    • public class Demo2_Thread {

    /**
     * @param args
     */
    public static void main(String[] args) {
        MyThread mt = new MyThread();                           //4,建立自定義類的物件
        mt.start();                                             //5,開啟執行緒

        for(int i = 0; i < 3000; i++) {
            System.out.println("bb");
        }
    }

}
class MyThread extends Thread {                                 //1,定義類繼承Thread
    public void run() {                                         //2,重寫run方法
        for(int i = 0; i < 3000; i++) {                         //3,將要執行的程式碼,寫在run方法中
            System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
        }
    }
}

24.05_多執行緒(多執行緒程式實現的方式2)(掌握)

  • 2.實現Runnable

    • 定義類實現Runnable介面
    • 實現run方法
    • 把新執行緒要做的事寫在run方法中
    • 建立自定義的Runnable的子類物件
    • 建立Thread物件, 傳入Runnable

    • 呼叫start()開啟新執行緒, 內部會自動呼叫Runnable的run()方法

      public class Demo3_Runnable {
    /**
     * @param args
     */
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();                       //4,建立自定義類物件
        //Runnable target = new MyRunnable();
        Thread t = new Thread(mr);                              //5,將其當作引數傳遞給Thread的建構函式
        t.start();                                              //6,開啟執行緒

        for(int i = 0; i < 3000; i++) {
            System.out.println("bb");
        }
    }
}

class MyRunnable implements Runnable {                          //1,自定義類實現Runnable介面
    @Override
    public void run() {                                         //2,重寫run方法
        for(int i = 0; i < 3000; i++) {                         //3,將要執行的程式碼,寫在run方法中
            System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
        }
    }

}

24.06_多執行緒(實現Runnable的原理)(瞭解)

  • 檢視原始碼
    • 1,看Thread類的建構函式,傳遞了Runnable介面的引用
    • 2,通過init()方法找到傳遞的target給成員變數的target賦值
    • 3,檢視run方法,發現run方法中有判斷,如果target不為null就會呼叫Runnable介面子類物件的run方法

24.07_多執行緒(兩種方式的區別)(掌握)

  • 檢視原始碼的區別:

    • a.繼承Thread : 由於子類重寫了Thread類的run(), 當呼叫start()時, 直接找子類的run()方法
    • b.實現Runnable : 建構函式中傳入了Runnable的引用, 成員變數記住了它, start()呼叫run()方法時內部判斷成員變數Runnable的引用是否為空, 不為空編譯時看的是Runnable的run(),執行時執行的是子類的run()方法

  • 繼承Thread

    • 好處是:可以直接使用Thread類中的方法,程式碼簡單
    • 弊端是:如果已經有了父類,就不能用這種方法
  • 實現Runnable介面
    • 好處是:即使自己定義的執行緒類有了父類也沒關係,因為有了父類也可以實現介面,而且介面是可以多實現的
    • 弊端是:不能直接使用Thread中的方法需要先獲取到執行緒物件後,才能得到Thread的方法,程式碼複雜

24.08_多執行緒(匿名內部類實現執行緒的兩種方式)(掌握)

  • 繼承Thread類

    new Thread() {                                                  //1,new 類(){}繼承這個類
    public void run() {                                         //2,重寫run方法
        for(int i = 0; i < 3000; i++) {                         //3,將要執行的程式碼,寫在run方法中
            System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
        }
    }
}.start();

  • 實現Runnable介面

    new Thread(new Runnable(){                                      //1,new 介面(){}實現這個介面
    public void run() {                                         //2,重寫run方法
        for(int i = 0; i < 3000; i++) {                         //3,將要執行的程式碼,寫在run方法中
            System.out.println("bb");
        }
    }
}).start();

24.09_多執行緒(獲取名字和設定名字)(掌握)

  • 1.獲取名字
    • 通過getName()方法獲取執行緒物件的名字

  • 2.設定名字

    • 通過建構函式可以傳入String型別的名字
    • new Thread("xxx") {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(this.getName() + "....aaaaaaaaaaaaaaaaaaaaaaa");
        }
    }
}.start();

new Thread("yyy") {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(this.getName() + "....bb");
        }
    }
}.start();
    • 通過setName(String)方法可以設定執行緒物件的名字
    • Thread t1 = new Thread() {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(this.getName() + "....aaaaaaaaaaaaaaaaaaaaaaa");
        }
    }
};

Thread t2 = new Thread() {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(this.getName() + "....bb");
        }
    }
};
t1.setName("芙蓉姐姐");
t2.setName("鳳姐");

t1.start();
t2.start();

24.10_多執行緒(獲取當前執行緒的物件)(掌握)

  • Thread.currentThread(), 主執行緒也可以獲取

    • new Thread(new Runnable() {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "...aaaaaaaaaaaaaaaaaaaaa");
        }
    }
}).start();

new Thread(new Runnable() {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "...bb");
        }
    }
}).start();
Thread.currentThread().setName("我是主執行緒");                    //獲取主函式執行緒的引用,並改名字
System.out.println(Thread.currentThread().getName());       //獲取主函式執行緒的引用,並獲取名字

24.11_多執行緒(休眠執行緒)(掌握)

  • Thread.sleep(毫秒,納秒), 控制當前執行緒休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000納秒 1000000000

        new Thread() {
        public void run() {
            for(int i = 0; i < 10; i++) {
                System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }.start();

    new Thread() {
        public void run() {
            for(int i = 0; i < 10; i++) {
                System.out.println(getName() + "...bb");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }.start();

24.12_多執行緒(守護執行緒)(掌握)

  • setDaemon(), 設定一個執行緒為守護執行緒, 該執行緒不會單獨執行, 當其他非守護執行緒都執行結束後, 自動退出

    • Thread t1 = new Thread() {
    public void run() {
        for(int i = 0; i < 50; i++) {
            System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
};

Thread t2 = new Thread() {
    public void run() {
        for(int i = 0; i < 5; i++) {
            System.out.println(getName() + "...bb");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
};

t1.setDaemon(true);                     //將t1設定為守護執行緒

t1.start();
t2.start();

24.13_多執行緒(加入執行緒)(掌握)

  • join(), 當前執行緒暫停, 等待指定的執行緒執行結束後, 當前執行緒再繼續

  • join(int), 可以等待指定的毫秒之後繼續

    • final Thread t1 = new Thread() {
    public void run() {
        for(int i = 0; i < 50; i++) {
            System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
};

Thread t2 = new Thread() {
    public void run() {
        for(int i = 0; i < 50; i++) {
            if(i == 2) {
                try {
                    //t1.join();                        //插隊,加入
                    t1.join(30);                        //加入,有固定的時間,過了固定時間,繼續交替執行
                    Thread.sleep(10);
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
            System.out.println(getName() + "...bb");

        }
    }
};

t1.start();
t2.start();

24.14_多執行緒(禮讓執行緒)(瞭解)

  • yield讓出cpu

24.15_多執行緒(設定執行緒的優先順序)(瞭解)

  • setPriority()設定執行緒的優先順序（數值越大，執行的次數先對而言多些）

24.16_多執行緒(同步程式碼塊)(掌握)

  • 1.什麼情況下需要同步
    • 當多執行緒併發, 有多段程式碼同時執行時, 我們希望某一段程式碼執行的過程中CPU不要切換到其他執行緒工作. 這時就需要同步.
    • 如果兩段程式碼是同步的, 那麼同一時間只能執行一段, 在一段程式碼沒執行結束之前, 不會執行另外一段程式碼.

  • 2.同步程式碼塊

    • 使用synchronized關鍵字加上一個鎖物件來定義一段程式碼, 這就叫同步程式碼塊

    • 多個同步程式碼塊如果使用相同的鎖物件, 那麼他們就是同步的

      class Printer {
    Demo d = new Demo();
    public static void print1() {
        synchronized(d){                //鎖物件可以是任意物件,但是被鎖的程式碼需要保證是同一把鎖,不能用匿名物件
            System.out.print("黑");
            System.out.print("馬");
            System.out.print("程");
            System.out.print("序");
            System.out.print("員");
            System.out.print("\r\n");
        }
    }

    public static void print2() {   
        synchronized(d){    
            System.out.print("傳");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
        }
    }
}

24.17_多執行緒(同步方法)(掌握)

  • 使用synchronized關鍵字修飾一個方法, 該方法中所有的程式碼都是同步的

    class Printer {
    public static void print1() {
        synchronized(Printer.class){                //鎖物件可以是任意物件,但是被鎖的程式碼需要保證是同一把鎖,不能用匿名物件
            System.out.print("黑");
            System.out.print("馬");
            System.out.print("程");
            System.out.print("序");
            System.out.print("員");
            System.out.print("\r\n");
        }
    }
    /*
     * 非靜態同步函式的鎖是:this
     * 靜態的同步函式的鎖是:位元組碼物件
     */
    public static synchronized void print2() {  
        System.out.print("傳");
        System.out.print("智");
        System.out.print("播");
        System.out.print("客");
        System.out.print("\r\n");
    }
}

24.18_多執行緒(執行緒安全問題)(掌握)

  • 多執行緒併發操作同一資料時, 就有可能出現執行緒安全問題

  • 使用同步技術可以解決這種問題, 把操作資料的程式碼進行同步, 不要多個執行緒一起操作

        public class Demo2_Synchronized {

        /**
         * @param args
         * 需求:鐵路售票,一共100張,通過四個視窗賣完.
         */
        public static void main(String[] args) {
            TicketsSeller t1 = new TicketsSeller();
            TicketsSeller t2 = new TicketsSeller();
            TicketsSeller t3 = new TicketsSeller();
            TicketsSeller t4 = new TicketsSeller();

            t1.setName("視窗1");
            t2.setName("視窗2");
            t3.setName("視窗3");
            t4.setName("視窗4");
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }

    }

    class TicketsSeller extends Thread {
        private static int tickets = 100;
        static Object obj = new Object();   //如果用引用資料型別成員變數當作鎖物件,必須是靜態的
        public TicketsSeller() {
            super();

        }
        public TicketsSeller(String name) {
            super(name);
        }
        public void run() {
            while(true) {
                synchronized(obj) {
                    if(tickets <= 0) 
                        break;
                    try {
                        Thread.sleep(10);//執行緒1睡,執行緒2睡,執行緒3睡,執行緒4睡
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                    System.out.println(getName() + "...這是第" + tickets-- + "號票");
                }
            }
        }
    }

24.19_多執行緒(火車站賣票的例子用實現Runnable介面)(掌握)

    public class Demo4_Ticket {

        /**
         * @param args
         * 火車站賣票的例子用實現Runnable介面
         */
        public static void main(String[] args) {
            MyTicket mt = new MyTicket();
            new Thread(mt).start();
            new Thread(mt).start();
            new Thread(mt).start();
            new Thread(mt).start();

            /*Thread t1 = new Thread(mt);               //多次啟動一個執行緒是非法的
            t1.start();
            t1.start();
            t1.start();
            t1.start();*/
        }

    }

    class MyTicket implements Runnable {
        private int tickets = 100;
        @Override
        public void run() {
            while(true) {
                synchronized(this) {
                    if(tickets <= 0) {
                        break;
                    }
                    try {
                        Thread.sleep(10);               //執行緒1睡,執行緒2睡,執行緒3睡,執行緒4睡
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "...這是第" + tickets-- + "號票");
                }
            }
        }
    }

24.20_多執行緒(死鎖)(瞭解)

  • 多執行緒同步的時候, 如果同步程式碼巢狀, 使用相同鎖, 就有可能出現死鎖

    • 儘量不要巢狀使用

      private static String s1 = "筷子左";
private static String s2 = "筷子右";
public static void main(String[] args) {
    new Thread() {
        public void run() {
            while(true) {
                synchronized(s1) {
                    System.out.println(getName() + "...拿到" + s1 + "等待" + s2);
                    synchronized(s2) {
                        System.out.println(getName() + "...拿到" + s2 + "開吃");
                    }
                }
            }
        }
    }.start();

    new Thread() {
        public void run() {
            while(true) {
                synchronized(s2) {
                    System.out.println(getName() + "...拿到" + s2 + "等待" + s1);
                    synchronized(s1) {
                        System.out.println(getName() + "...拿到" + s1 + "開吃");
                    }
                }
            }
        }
    }.start();
}

24.21_多執行緒(以前的執行緒安全的類回顧)(掌握)

  • A:回顧以前說過的執行緒安全問題
    • 看原始碼：Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
    • Vector是執行緒安全的,ArrayList是執行緒不安全的
    • StringBuffer是執行緒安全的,StringBuilder是執行緒不安全的
    • Hashtable是執行緒安全的,HashMap是執行緒不安全的

24.22_多執行緒(總結)

相關推薦

多執行緒+JAVA學習筆記-DAY24

24.01_多執行緒(多執行緒的引入)(瞭解) 1.什麼是執行緒 執行緒是程式執行的一條路徑, 一個程序中可以包含多條執行緒 多執行緒併發執行可以提高程式的效率, 可以同時完成多項工作 2.多執行緒的應用場景 紅

201711671103《JAVA程式設計》第十二章多執行緒機制學習筆記

教材學習內容總結 1.執行緒是依附於程序的，程序是分配資源的最小單位，執行緒是比程序更小的執行單位。一個程序可以產生多個執行緒，形成多條執行線索。每條線索，即每個執行緒也有它自身的產生，存在和消亡過程，也是一個動態的概念。 2.JAVA 中的多執行緒機制：多執行緒是指一個應用程式同時存在好幾

【自用】java多執行緒程式設計學習筆記（程式碼片段來源於網路）

執行緒的基本概念 執行緒是在邏輯上等同於作業系統中說的程序，是程序的細分。比如我們使用同一個軟體同時對電腦進行體檢和防毒的時候，我們就是開啟了那個軟體的程序的兩個執行緒，在邏輯上這兩個執行緒是同時被cpu執行的。 執行緒的生命週期 執行緒的生命週期分為建立，就緒，執行，

C++ 多執行緒pthread 學習筆記

本篇是我在學習C++多執行緒的時候做的筆記，主要記錄的是基礎的流程，部分程式碼例項，以及重點函式的說明。 pthread 入口函式型別說明 void * func1(void * t) void* 表示無型別指標 void*作為函式引數，表示函式接收一個指標，不管是什麼型別

多執行緒程式設計學習筆記——執行緒同步（三）

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; //引入執行緒 using System.Diagnostics; namesp

Java多執行緒程式設計學習總結（二）

  （尊重勞動成果，轉載請註明出處：https://blog.csdn.net/qq_25827845/article/details/84894463冷血之心的部落格） 系列文章： Java多執行緒程式設計學習總結（一） Java多執行緒程式設計學習總結（二） 前

JAVA多執行緒的學習

1、Thread.yield方法宣告把CPU讓給其他具有相同優先順序的執行緒去執行，不過這只是一個暗示，並沒有保障機制。 2、Executor       執行器，管理Thread物件。       語法demo：      ExecutorService

Java 多執行緒程式設計學習總結（一）

定義篇 程序(Process)和執行緒(Thread) 怎樣實現多工處理（Multitasking）？ 多工處理是同時執行多個任務的過程。我們使用多工處理來利用 CPU。可通過兩種方式實現多工處理: · 基於程序的多工 (多重處理) · 基於執行緒的多工處理

Java多執行緒程式設計總結筆記——03概念與原理

作業系統中執行緒和程序的概念 現在的作業系統是多工作業系統。多執行緒是實現多工的一種方式。 程序是指一個記憶體中執行的應用程式，每個程序都有自己獨立的一塊記憶體空間，一個程序中可以啟動多個執行緒。比如在Windows系統中，一個執行的exe就是一個程序。執行

Java多執行緒程式設計總結筆記——02多執行緒基礎知識

讀解Thread類API 構造方法摘要 Thread(Runnable target) 分配新的 Thread 物件。 Thread(String name) 分配新的 Thread 物件。 方法摘要 static Thread cur

Java多執行緒程式設計總結筆記——01 Java語言的執行緒

GUI應用程式 幾乎所有的GUI應用程式都會用多執行緒。舉例來說加入現在有人在用word編輯一個比較大的文字檔案剛剛才做過單字“查詢”操作，當word進行查詢時，螢幕上會出現“停止查詢按鈕”，使用者可以隨時停止查詢。這個功能其實就用到了多執行緒。 （1）執行

java併發與多執行緒API學習

Executor介面 public interface Executor { void execute(Runnable command); }     Executor介面中之定義了一個方法execute（Runnable command），該

Java多執行緒程式設計學習

擴充套件Java.lang.Thread類 實現java.lang.Runnable介面 Thread和Runnable的區別 執行緒狀態轉換 執行緒排程 程序：每個程序都有獨立的程式碼和資料空間(程序上下文)，程序間的切換比較大，一個進行包含1-n

JAVA jdk 執行緒池學習筆記

什麼情況下會用到執行緒池呢？？？？？ 1. 單個任務處理的時間比較短 2. 將需處理的任務的數量大 使用執行緒池的好處 1.減少在建立和銷燬執行緒上所花的時間以及系統資源的開銷 2.如不使用執行緒池，有可能造成系統建立大量執行緒而導致消耗

Java多執行緒程式設計學習與實踐

怎麼樣才算得上熟悉多執行緒程式設計？第一，明白程序和執行緒的基本概念第二，明白保護執行緒安全的基本方法有哪些第三，明白這些執行緒安全的方法，包括互斥鎖，自旋鎖，無鎖程式設計的適用的業務場景是什麼？從OS和硬體角度說說原理是怎麼樣的？開銷在哪裡？第四，能在現場藉助cas操作，風

多執行緒程式設計學習六(Java 中的阻塞佇列).

介紹 阻塞佇列（BlockingQueue）是指當佇列滿時，佇列會阻塞插入元素的執行緒，直到佇列不滿；當佇列空時，佇列會阻塞獲得元素的執行緒，直到佇列變非空。阻塞佇列就是生產者用來存放元素、消費者用來獲取元素的容器。 當執行緒 插入/獲取 動作由於佇列 滿/空 阻塞後，佇列也提供了一些機制去處理，或丟擲異常，

單執行緒的弊端，多執行緒基礎學習

using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using

多執行緒的學習與總結

單執行緒：        只有一個順序執行流        例如：單執行緒的程式如同只僱傭一個服務員的餐廳，他必須做完一件事情後才可以做下一件事情； 多執行緒：        可以

多執行緒深入學習及面試解決思路

課程目標 執行緒與程序區別 為什麼要使用多執行緒？ 多執行緒應用場景？ 多執行緒建立方式 獲取執行緒物件以及名稱 守護執行緒 多執行緒執行狀態 join()方法作用 多執行緒分批處理資料 作業題 面試題 備註單詞 執行緒與程序區別

007.多執行緒-Java記憶體模型

Java記憶體模型 ( Java Memory Model , JMM ) JMM主要是規定了執行緒與記憶體之間的一些關係。 Java記憶體模型中規定，所有的變數都儲存在主記憶體中， 對所有執行緒都是共享的。 而每個執行緒都有自己的工作記憶體。 工作記憶體中儲存的是對主記憶體