2. 程式人生 > >java核心技術-多執行緒基礎

java核心技術-多執行緒基礎

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

程序、執行緒

​ 程序(Process) 是程式的執行例項。例如，一個執行的 Eclipse 就是一個程序。程序是程式向作業系統申請資源(如記憶體空間和檔案控制代碼)的基本單位。執行緒(Thread)是程序中可獨立執行的最小單位。一個程序可以包含多個執行緒。程序和執行緒的關係，好比一個營業中的飯店與其正在工作的員工之間的關係。

1.1 執行緒的建立、啟動與執行

在 Java 中實現多執行緒主要用兩種手段，一種是繼承 Thread 類，另一種就是實現 Runnable 介面。(當然還有Callable和執行緒池)。下面我們就分別來介紹這兩種方式的使用,其他請關注此部落格下文。

(1).繼承Thread的類

public class PrimeThread extends Thread{
    //執行緒執行體
    @Override
    public void run(){
        
        for(int i = 0; i < 100; i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + "=" + i);
            }
        }
        
    }
    
}
public class TestThread {
    public static void main(String[] args) {
        //新建一個執行緒
        PrimeThread p1 = new PrimeThread();
        //啟動一個執行緒
        p1.start();
        
        PrimeThread p2 = new PrimeThread();
        p2.start();
        
        
        for(int i = 0; i < 100; i++ ){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + "=" + i);
            }
        }
        
    }
}

(2).實現 Runnable介面

public class Ticket implements Runnable{
    
    private int ticket = 100;

    @Override
    public void run() {
        while(ticket > 0){
            System.out.println(Thread.currentThread().getName() + "=" + --ticket);
        }
        
    }
}

public class TestThread2 {
    public static void main(String[] args) {
        
        Ticket ticket = new Ticket();
        
        //雖然是實現了Runnable介面 本質上只是實現了執行緒執行體 啟動工作還是需要Thread類來進行
        Thread t1 = new Thread(ticket,"售票視窗一");
        t1.start();
        
        Thread t2 = new Thread(ticket,"售票視窗二");
        t2.start();
        
        Thread t3 = new Thread(ticket,"售票視窗三");
        t3.start();
    }
}

兩種實現方式的對比：

1.從面向物件程式設計角度看：第一種建立方式(繼承Thread類) 是一種基礎繼承的技術,第二種建立方式(以Runnable介面例項為構造器引數直接通過new建立Thread例項)是一種基礎組合的技術。方式二不僅會避免單繼承的尷尬，也會降低類與類之間的耦合性。

2.從物件共享角度看：第二種建立方式意味著多個執行緒例項可以共享同一個Runnable例項。而第一種方式則需要依賴static關鍵字來完成操作。

1.2 執行緒的控制

Java的排程方法

同優先順序執行緒組成先進先出佇列（先到先服務），使用時間片策略

對高優先順序，使用優先排程的搶佔式策略

Thread類的相關方法：

  • sleep(long millis) : 是 Thread 類中的靜態方法，使當前執行緒進入睡眠狀態
  • join() / join(long millis) : 是一個例項方法，使當前執行緒進入阻塞狀態
  • interrupt() : 中斷阻塞狀態的執行緒
  • isAlive() : 判斷當前執行緒是否處於存活狀態
  • yield() : 執行緒讓步
public class TestThread3 {
    public static void main(String[] args) throws Exception {
        
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 1; i < 100;i++){
                    if(i % 2 == 0){
                    System.out.println(Thread.currentThread().getName() + "=" + i);
                    }
                }
                    
            }
        },"執行緒1");
        t1.start();
        //執行緒1在 sleep之前就執行完了
        t1.sleep(10000);
        //join方法 迫使t2 必須等執行緒1 執行完 才能執行 然而 t1輸出完自己的 睡著了 t2被迫等了10秒
        t1.join();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 1; i < 100;i++){
                    if(i % 2 != 0){
                        System.out.println(Thread.currentThread().getName() + "=" + i);
                    }
                }
            }
        },"執行緒2");
        t2.start();
        
    }
}

1.3 執行緒的同步

執行緒同步：模擬售票程式，實現三個視窗同時售票 100 張 （1.1案例）

問題：當三個視窗同時訪問共享資料時，產生了無序、重複、超額售票等多執行緒安全問題

解決：將需要訪問的共享資料“包起來”，視為一個整體，確保一次只能有一個執行緒執行流訪問該“共享資料”

Java給上述問題提供了幾種相應的解決方法

(1).同步程式碼塊

synchronized(同步監視器){

//需要訪問的共享資料

}

同步監視器 ： 俗稱“鎖”，可以使用任意物件的引用充當，注意確保多個執行緒持有同一把鎖(同一個物件)

(2).同步方法

同步方法 : 在方法宣告處加 synchronized. 注意：非靜態同步方法隱式的鎖 ---- this

例如：

public synchronized void show(){}

(3).同步鎖

同步鎖 ： Lock 介面

同步程式碼塊

public class SafeTicket implements Runnable{
    
    private int ticket = 100;
    
    @Override
    public void run() {
        while(true){
            //使用同步程式碼塊
            synchronized (this) {
                if(ticket > 0){
                        System.out.println(Thread.currentThread().getName() + " 完成售票,餘票:" + --ticket);
                }
            }
            
            
        }
    }

}

同步方法：

public class SafeTicket implements Runnable{
    
    private int ticket = 100;
    
    @Override
    public void run() {
        while(true){
            //使用同步程式碼塊
            sale();
            
        }
    }
    
    public synchronized void sale(){
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName() + " 完成售票,餘票:" + 
--ticket);
        }
    }
    
}

同步鎖

public class SafeTicket implements Runnable{
    
    private int ticket = 100;
    
    private Lock l = new ReentrantLock();
    
    @Override
    public void run() {
        while(true){
            l.lock();
            try {
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + " 完成售票,餘票:" + 
--ticket);
                }
            } finally {
                l.unlock();//釋放鎖
            }
            
        }
    }
    
}

死鎖

死鎖 是指兩個或兩個以上的程序在執行過程中，由於競爭資源或者由於彼此通訊而造成的一種阻塞的現象，若無外力作用，它們都將無法推進下去。此時稱系統處於 死鎖 狀態或系統產生了 死鎖 ，這些永遠在互相等待的程序稱為 死鎖 程序

public class TestDeadLock {
    public static void main(String[] args) {
        final StringBuffer s1 = new StringBuffer();
        final StringBuffer s2 = new StringBuffer();
        
        new Thread() {
            public void run() {
                synchronized (s1) {
                    s2.append("A");
                    
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                    
                    synchronized (s2) {
                        s2.append("B");
                        System.out.print(s1);
                        System.out.print(s2);
                    }
                }
            }
        }.start();
        
        new Thread() {
            public void run() {
                synchronized (s2) {
                    s2.append("C");
                    synchronized (s1) {
                        s1.append("D");
                        System.out.print(s2);
                        System.out.print(s1);
                    }
                }
            }
        }.start();
    }
}

1.4 執行緒的通訊

在 java.lang.Object 類中：

wait() : 使當前“同步監視器”上的執行緒進入等待狀態。同時釋放鎖

notify() / notifyAll() : 喚醒當前“同步監視器”上的（一個/所有）等待狀態的執行緒

注意：上述方法必須使用在同步中

場景1：使用兩個執行緒列印 1-100 執行緒1和執行緒2交替列印

public class MyThread implements Runnable{
    
    int i = 0;
    
    @Override
    public void run() {
        
        while(true){
            synchronized (this) {
                this.notify();
                
                if(i <= 100){
                    System.out.println(Thread.currentThread().getName() + "=" + i++);
                }
                
                try {
                    this.wait();
                } catch (InterruptedException e) {
                }
            }
            
        }
        
    }
    
}
public class TestThread4 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        
        Thread t1 = new Thread(myThread,"執行緒1");
        Thread t2 = new Thread(myThread,"執行緒2");
        
        t1.start();
        t2.start();
    }
}

經典例題:生產者/消費者問題

  • 生產者(Productor)將產品交給店員(Clerk)，而消費者(Customer)從店員處取走產品，
  • 店員一次只能持有固定數量的產品(比如:20），如果生產者試圖生產更多的產品，店員會叫生產者停一下，
  • 如果店中有空位放產品了再通知生產者繼續生產；
  • 如果店中沒有產品了，店員會告訴消費者等一下，如果店中有產品了再通知消費者來取走產品。
public class TestProduct {
    
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        
        Productor pro = new Productor(clerk);
        Customer cus = new Customer(clerk);
        
        new Thread(pro).start();
        new Thread(cus).start();
    }

}

// 店員
class Clerk {

    private int product;

    // 進貨
    public synchronized void getProduct() {
        if (product >= 20) {
            System.out.println("產品已滿！");
            
            try {
                wait();
            } catch (InterruptedException e) {
            }
            
        } else {
            System.out.println("生產者生產了第" + ++product + " 個產品");
            
            notifyAll();
        }
    }

    // 賣貨
    public synchronized void saleProduct() {
        if (product <= 0) {
            System.out.println("缺貨！");
            
            try {
                wait();
            } catch (InterruptedException e) {
            }
            
        } else {
            System.out.println("消費者消費了第" + --product + " 個產品");
            
            notifyAll();
        }
    }

}

// 生產者
class Productor implements Runnable {

    private Clerk clerk;

    public Productor() {
    }

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    public Clerk getClerk() {
        return clerk;
    }

    public void setClerk(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while (true) {
            clerk.getProduct();
        }
    }

}

// 消費者
class Customer implements Runnable {

    private Clerk clerk;

    public Customer() {
    }

    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    public Clerk getClerk() {
        return clerk;
    }

    public void setClerk(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public String toString() {
        return "Customer [clerk=" + clerk + "]";
    }

    @Override
    public void run() {
        while(true){
            clerk.saleProduct();
        }
    }

}

相關推薦

java核心技術-多執行緒基礎

程序、執行緒 ​ 程序(Process) 是程式的執行例項。例如，一個執行的 Eclipse 就是一個程序。程序是程式向作業系統申請資源(如記憶體空間和檔案控制代碼)的基本單位。執行緒(Thread)是程序中可獨立執行的最小單位。一個程序可以包含多個執行緒。程序和執行緒的關係，好比一個營業中的飯店與其正在工

java核心技術-多線程基礎

notifyall -- pri inf 參數 for 告訴 override new t 進程、線程 ? 進程(Process) 是程序的運行實例。例如，一個運行的 Eclipse 就是一個進程。進程是程序向操作系統申請資源(如內存空間和文件句柄)的基本單位。線程(Thr

Java高併發——多執行緒基礎

       在上一篇 JAVA高併發——瞭解並行世界 中我們回顧了一些多執行緒的概念知識。這裡先舉個例子，來看現實生活中的多執行緒例子：一個家庭中有爸爸、媽媽、兒子，家中有電視、洗衣機、書桌等，如果媽媽領著兒子出去了，爸爸就可以

java中的多執行緒 // 基礎

java 中的多執行緒 簡介 　　程序 ： 指正在執行的程式，並具有一定的獨立能力，即 當硬碟中的程式進入到記憶體中執行時，就變成了一個程序 　　執行緒 ： 是程序中的一個執行單元，負責當前程式的執行。執行緒就是CPU通向程式的路徑 　　　　　  一個程序中只有一個執行緒，單執行緒程式 　

Java多執行緒核心技術(六)執行緒組與執行緒異常

本文應注重掌握如下知識點： 執行緒組的使用 如何切換執行緒狀態 SimpleDataFormat 類與多執行緒的解決辦法 如何處理執行緒的異常 1.執行緒的狀態 執行緒物件在不同執行時期有不同的狀態，狀態資訊就處於State列舉類中，如圖所示： 執行緒狀態 初始(NEW)：新建立了一個執行緒物件，但還

Java多執行緒-基礎及實現

1. 什麼是執行緒 執行緒是程序內的執行單元     某個程序當中都有若干個執行緒。 執行緒是程序內的執行單元。 使用執行緒的原因是，程序的切換是非常重量級

java併發程式設計一一多執行緒基礎快速入門

1.執行緒與程序的區別 每個正在系統上執行的程式都是一個程序。每個程序包含一到多個執行緒。執行緒是一組指令的集合，或者是程式的特殊段，他可以在程式裡獨立執行。也可以把它理解為程式碼執行的上下文。 所以執行緒基本是輕量級的程序，它負責在單個程式裡執行任務。通常有作業系統負責多個執行緒

java 多執行緒基礎2

      多執行緒(加入執行緒join) thread.join(); 被.join()的執行緒優先執行 多執行緒(執行緒優先順序Priority) Thread.setPriority(1-10)執行緒預設優先順序是5。執行緒優先順序的範圍是

java多執行緒 基礎

引入  1.什麼是執行緒           執行緒是程式執行的一條路徑, 一個程序中可以包含多條執行緒        

Java：多執行緒基礎

Java中的多執行緒 程序：一個程式的執行 執行緒：程式中某個順序的流程控制，通俗來講，就是不同的任務 一個程序可以有多個執行緒 執行緒的分類 普通執行緒(非Daemon執行緒) 在Java中，如果還有非Daemon執行緒，整個程式就不會結束 Daemon

Java多執行緒-基礎篇（一）

多執行緒---基礎篇，本文主要針對多執行緒的基礎進行復習，內容包括執行緒的理解，建立方式，Thread類函式理解； 1、執行緒的理解：OS系統角度：每個執行的程式都會被作業系統建立對應的程序（包括分配的資源、PCB等），程序是作業系統分配資源的基本單位（理解：程式執行需要空間，作業系統建立對應程序時

Java多執行緒基礎之手撕生產者和消費者模式

問題描述 資料結構： 生產者/消費者 快取區(共享資源) 規則： 生產/消費者同時操作快取區。 當快取區為空的時候，消費者不能消費，即消費者阻塞。 當快取區為滿的時候，生產者不能生產，即生產者阻

java多執行緒基礎

本文就java多執行緒的基本使用方法、執行緒同步、執行緒狀態、執行緒函式等記錄一些總結。         程序：程序是資源分配的最小單位。每個程序都有獨立的程式碼和資料空間，程序間切換會有較大的開銷，一個程序往往包含多個執行緒。         執行緒：執行緒是CPU排程

Java 進階——多執行緒優化之執行緒池 ThreadPoolExecutor的核心容器阻塞佇列詳解（一）

#引言 多執行緒我想無論是後端開發，還是對於App開發者來說都不會陌生，何況Android強制要求不能在主執行緒中做網路請求，於是乎，在很多初學者或者App的原始碼中會出現會多的new Thread…的方式，這樣的程式碼是不優雅而且存在很多的隱患，假如說在使用者

Java多執行緒：多執行緒基礎

多執行緒基礎 多執行緒實現-Thread和Runnable 通常使用如下程式碼啟動一個新的執行緒： private void startNewThread1() { new Thread() { @Override pub

Java多執行緒基礎之停止執行緒

JAVA中有3種終止正在執行的執行緒： 使用退出標誌，使執行緒正常的退出，也就是run方法執行完成後執行緒終止。 使用stop方式強行終止執行緒，但是不推薦使用這種方式，因為stop和suspend及resume一樣，都是作廢過期的方法，使用它們可能產生不可預料的後果。 使用i

Java多執行緒基礎之資料共享引發的“非執行緒安全”

例項變數與執行緒安全      自定義執行緒類中的例項變數針對其他執行緒可以有共享與不共享之分，這在多個執行緒之間進行互動時是很重要的一個技術點。     一 、不共享資料的情況        

Java多執行緒基礎之執行緒特性

核心知識: ① 使用多執行緒技術時，程式碼的執行結果與程式碼執行的順序或呼叫順序是無關的 public class MyThread extends Thread{ @Override public void run() { super.run(); System.o

JAVA多執行緒基礎入門

        本篇部落格主要通過以下幾個方面向大家闡述JAVA中的多執行緒內容，可能篇幅比較長，希望大家能有耐心的讀下去。        在實際應用中， 多執行緒非常有用。例如， 一個瀏覽器可以同時下載幾幅圖片。一個 Web伺服器需要同時處理幾個併發的請求。 程式 、程

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

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