2. 程式人生 > >java多執行緒一 基本實現方法、消費者生產者佇列、死鎖

java多執行緒一 基本實現方法、消費者生產者佇列、死鎖

阿新 • • 發佈：2019-02-15

1.基本概念圖

這裡寫圖片描述
四個狀態、start 代表被建立、run表示正在執行、阻塞（在幹別的事情去了，可以把資源空出來給別人用）、死亡。
核心思想是提高cpu的使用率，你幹別的事去了我來利用cpu啊，難點是同步，同時訪問資料，一個廁所只有一個坑，倆個人一起上是不文明的。
參考：http://blog.csdn.net/zjwcdd/article/details/51517096

2.基本使用方法

倆種常用使用方法，一個是整合Thread類，一種是實現Runnable介面，因為java有單繼承的限制，而介面Runnable可以重複實現多次，還可以利用執行緒池，推薦介面實現方法：

1.繼承方法

class JavaThread extends Thread{
    private String name;
    public JavaThread(String name) {
        this.name=name;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "執行  :  " + i);
            try {
                sleep((int) Math.random() * 10
 
);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
 class Main {

    public static void main(String[] args) {
        JavaThread mTh1=new JavaThread("A");
        JavaThread mTh2=new JavaThread("B");
        mTh1.start();
        mTh2.start();

    }

}

輸出

B執行  :  0
A執行  :  0#可以發現A也可以搶cpu用
B執行  :  1
A執行  :  1
B執行  :  2
A執行  :  2
B執行  :  3
A執行  :  3
B執行  :  4
A執行  :  4

2.實現Runable介面

class JavaThread implements Runnable{
    private String name;

    public JavaThread(String name) {
        this.name=name;
    }

    @Override//表示實現介面的時候過載了
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "執行  :  " + i);
            try {
                Thread.sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}
class Main {

    public static void main(String[] args) {
        new Thread(new JavaThread("C")).start();
        new Thread(new JavaThread("D")).start();
    }

}

輸出

C執行  :  0
D執行  :  0#可以發現D也在搶C的資源
C執行  :  1
D執行  :  1
C執行  :  2
D執行  :  2
C執行  :  3
D執行  :  3
C執行  :  4
D執行  :  4

另外提一點join，主程序做完了想關閉程式，你新建的子程序沒幹完事也也也也也也直接退出的話會出問題的，join是主程序等你一起退出，這個第一次用的時候坑了我好久。
參考：java多執行緒吐血整理http://blog.csdn.net/evankaka/article/details/44153709

3.生產者消費者模式

優點：利用很多個生產者（執行緒）去生產東西，利用很多個消費者（也是執行緒）去消費生產的東西，好處是利用多執行緒來處理，省時間。注意 生產者生產東西的總數有個限制，超過就暫時不生產，等消費者消費完，不然會通貨膨脹。消費者有東西就消費，沒東西就等待。
難點：生產者和消費者之間的資料的同步的問題（一個檔案只能同時讓一個人在修改，一個廁所只能一個人同時在用）
模式圖：
這裡寫圖片描述
參考：https://www.cnblogs.com/chentingk/p/6497107.html
實現也有很多種方式：
可以參考這個：
生產者/消費者問題的多種Java實現方式http://blog.csdn.net/monkey_d_meng/article/details/6251879
這裡舉出另外一種：



import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 多執行緒模擬實現生產者／消費者模型
 *
 * @author 林計欽
 * @version 1.0 2013-7-25 下午05:23:11
 */
public class ProducerConsumer {
    /**
     *
     * 定義裝蘋果的籃子
     *
     */
    public class Basket {
        // 籃子，能夠容納3個蘋果
        BlockingQueue<String> basket = new LinkedBlockingQueue<String>(3);

        // 生產蘋果，放入籃子
        public void produce() throws InterruptedException {
            // put方法放入一個蘋果，若basket滿了，等到basket有位置
            basket.put("An apple");
        }

        // 消費蘋果，從籃子中取走
        public String consume() throws InterruptedException {
            // take方法取出一個蘋果，若basket為空，等到basket有蘋果為止(獲取並移除此佇列的頭部)
            return basket.take();
        }
    }

    // 定義蘋果生產者
    class Producer implements Runnable {
        private String instance;
        private Basket basket;

        public Producer(String instance, Basket basket) {
            this.instance = instance;
            this.basket = basket;
        }

        public void run() {
            try {
                while (true) {
                    // 生產蘋果
                    System.out.println("生產者準備生產蘋果：" + instance);
                    basket.produce();
                    System.out.println("!生產者生產蘋果完畢：" + instance);
                    // 休眠300ms
                    Thread.sleep(300);
                }
            } catch (InterruptedException ex) {
                System.out.println("Producer Interrupted");
            }
        }
    }

    // 定義蘋果消費者
    class Consumer implements Runnable {
        private String instance;
        private Basket basket;

        public Consumer(String instance, Basket basket) {
            this.instance = instance;
            this.basket = basket;
        }

        public void run() {
            try {
                while (true) {
                    // 消費蘋果
                    System.out.println("消費者準備消費蘋果：" + instance);
                    System.out.println(basket.consume());
                    System.out.println("!消費者消費蘋果完畢：" + instance);
                    // 休眠1000ms
                    Thread.sleep(1000);
                }
            } catch (InterruptedException ex) {
                System.out.println("Consumer Interrupted");
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumer test = new ProducerConsumer();

        // 建立一個裝蘋果的籃子
        Basket basket = test.new Basket();

        ExecutorService service = Executors.newCachedThreadPool();
        Producer producer = test.new Producer("生產者001", basket);
        Producer producer2 = test.new Producer("生產者002", basket);
        Consumer consumer = test.new Consumer("消費者001", basket);
        service.submit(producer);
        service.submit(producer2);
        service.submit(consumer);
        // 程式執行5s後，所有任務停止
//        try {
//            Thread.sleep(1000 * 5);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//        service.shutdownNow();
    }

}

輸出：

生產者準備生產蘋果：生產者002
消費者準備消費蘋果：消費者001
生產者準備生產蘋果：生產者001
!生產者生產蘋果完畢：生產者002
!生產者生產蘋果完畢：生產者001
An apple
!消費者消費蘋果完畢：消費者001
生產者準備生產蘋果：生產者001
!生產者生產蘋果完畢：生產者001

4.死鎖

鎖，同步是解決多執行緒下保證只有一個執行緒在處理這個檔案的基本方式，我鎖住了，別人就不能訪問了，直到我不需要了，你才能訪問它，上面中的執行緒安全的佇列就是利用這個原理實現的，死鎖就是A在等B某個訪問結束，B也在等A某個訪問結束，倆個都在等，一直等，這樣就出現問題了。
總感覺會出現這個問題是因為計算機太傻比了，訪問的時候給檔案加個鎖，誰來我給誰，或者讓它等不行嗎？不可以嗎？可能有另外的開銷？為啥對執行緒上鎖？是不是我理解錯了。
這裡寫圖片描述
上圖中，就是倆個人都在等，都不服輸，就會出現死鎖，程式碼如下：

import java.util.Date;

public class LockTest {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    public static void main(String[] args) {
        LockA la = new LockA();
        new Thread(la).start();
        LockB lb = new LockB();
        new Thread(lb).start();
    }
}
class LockA implements Runnable{
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockA 開始執行");
            while(true){
                synchronized (LockTest.obj1) {
                    System.out.println(new Date().toString() + " LockA 鎖住 obj1");
                    Thread.sleep(3000); // 此處等待是給B能鎖住機會
                    synchronized (LockTest.obj2) {
                        System.out.println(new Date().toString() + " LockA 鎖住 obj2");
                        Thread.sleep(60 * 1000); // 為測試，佔用了就不放
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class LockB implements Runnable{
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockB 開始執行");
            while(true){
                synchronized (LockTest.obj2) {
                    System.out.println(new Date().toString() + " LockB 鎖住 obj2");
                    Thread.sleep(3000); // 此處等待是給A能鎖住機會
                    synchronized (LockTest.obj1) {
                        System.out.println(new Date().toString() + " LockB 鎖住 obj1");
                        Thread.sleep(60 * 1000); // 為測試，佔用了就不放
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

輸出就是A鎖住了，B鎖住了，然後就不動了：

Wed Jan 10 19:36:44 GMT+08:00 2018 LockA 開始執行
Wed Jan 10 19:36:44 GMT+08:00 2018 LockA 鎖住 obj1
Wed Jan 10 19:36:44 GMT+08:00 2018 LockB 開始執行
Wed Jan 10 19:36:44 GMT+08:00 2018 LockB 鎖住 obj2
後面就沒有了

如何避免死鎖呢，別一個鎖著又去鎖另外一個

import java.util.Date;

public class UnLock {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    public static void main(String[] args) {
        LockA la = new LockA(obj1,obj2);
        new Thread(la).start();
        LockB lb = new LockB(obj1,obj2);
        new Thread(lb).start();
    }
}
class LockA implements Runnable{
    private Object obj1;
    private Object obj2;
    public LockA(Object o1,Object o2){
        this.obj1 = o1;
        this.obj2 = o2;
    }
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + " acquiring lock on " + obj1);
        synchronized (obj1) {
            System.out.println(name + " acquired lock on " + obj1);
//            work();
        }
        System.out.println(name + " released lock on " + obj1);
        System.out.println(name + " acquiring lock on " + obj2);
        synchronized (obj2) {
            System.out.println(name + " acquired lock on " + obj2);
//            work();
        }
        System.out.println(name + " released lock on " + obj2);

        System.out.println(name + " finished execution.");
    }
}
class LockB implements Runnable{
    private Object obj1;
    private Object obj2;
    public LockB(Object o1,Object o2){
        this.obj1 = o1;
        this.obj2 = o2;
    }
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + " acquiring lock on " + obj2);
        synchronized (obj2) {
            System.out.println(name + " acquired lock on " + obj2);
//            work();
        }
        System.out.println(name + " released lock on " + obj2);
        System.out.println(name + " acquiring lock on " + obj1);
        synchronized (obj1) {
            System.out.println(name + " acquired lock on " + obj1);
        }
        System.out.println(name + " released lock on " + obj1);

        System.out.println(name + " finished execution.");
    }
}
Thread-0 acquiring lock on obj1
Thread-1 acquiring lock on obj2
Thread-0 acquired lock on obj1
Thread-1 acquired lock on obj2
Thread-0 released lock on obj1
Thread-1 released lock on obj2
Thread-0 acquiring lock on obj2
Thread-1 acquiring lock on obj1
Thread-0 acquired lock on obj2
Thread-1 acquired lock on obj1
Thread-0 released lock on obj2
Thread-1 released lock on obj1
Thread-1 finished execution.
Thread-0 finished execution.

相關推薦

java多執行緒一 基本實現方法、消費者生產者佇列、死鎖

1.基本概念圖 四個狀態、start 代表被建立、run表示正在執行、阻塞（在幹別的事情去了，可以把資源空出來給別人用）、死亡。 核心思想是提高cpu的使用率，你幹別的事去了我來利用cpu啊，難點是同步，同時訪問資料，一個廁所只有一個坑，倆個人一起上是不

Java多執行緒3種實現方法

Java中的多執行緒有三種實現方式：1.繼承Thread類，重寫run方法。Thread本質上也是一個實現了Runnable的例項，他代表一個執行緒的例項，並且啟動執行緒的唯一方法就是通過Thread類的start方法。2.實現Runnable介面，並實現該介面的run()

Java——實現Java多執行緒的三種方法

Java虛擬機器允許應用程式併發地執行多個執行緒。在Java語言中，多執行緒的實現一般有以下3種方法，其中前兩種是最常用的方法。 1.繼承Thread類，重寫run（）方法 Thread本質上也是實現了Runnable介面的一個例項，它代表一個執行緒的例項。並且，啟動執行緒的唯一方法就是通過

Java 多執行緒 join和interrupt 方法

簡述： 使用Java多執行緒中join和interrupt函式 《Java程式設計思想》 P669 ~ P670 一個執行緒可以再其他執行緒上呼叫join()方法，其效果是等待一段時間直到第二個執行緒結束才繼續執行。 如果某個執行緒在另一個執行緒t上呼叫t.join(), 此

Java多執行緒-基礎及實現

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

Java多執行緒-46-用實現runnable的方式實現火車票賣票

前面一篇，我們介紹了火車票賣票多執行緒的實現和安全問題，實現方式是寫一個類來繼承Thread類。前面我們介紹了實現多執行緒有兩種方式，第一種是作為Thread類的子類，第二種是實現Runnable，這篇就來寫一個實現Runnable的賣火車票的程式碼。 package thread; pu

java:多執行緒程式的實現方式

1.一種方法是將類宣告為 Thread 的子類。該子類應重寫 Thread 類的 run 方法。 public class Demo2_Thread { public static void main(String[] args) { MyThread mt=new MyThread

Java多執行緒2.9.實現執行緒的常用方式-匿名內部類

實現執行緒的常用方式-匿名內部類 1、匿名內部類的格式 匿名內部類的格式。 本質：是該類或者介面的子類物件。 new 類名或者介面名() { 重寫方法; }; 2、實現執行緒的常用

Java多執行緒(一)執行緒基礎

1.執行緒與程序 程序： 是併發執行的程式在執行過程中分配和管理資源的基本單位，是一個動態概念，程序是系統中獨立存在的實體，擁有自己獨立的資源，擁有自己私有的地址空間。程序的實質，就是程式在多道程式系統中的一次執行過程，它是動態產生，動態消亡的，具有自己的生命週

深入理解Java多執行緒--synchronized的實現原理

執行緒安全是多執行緒程式設計中的一個重要的知識點，何為執行緒安全？在多執行緒併發中，有很多資料是執行緒共享的，當我們某個執行緒去操作共享資料的時候，需要先將共享資料複製到當前執行緒的記憶體空間中來，然後進行操作完畢之後再將資料更新到共享空間中去。這就造成了一個問題，當我們有多個執行緒去讀取和操作

java多執行緒-Thread的yield方法

yield表示當前執行緒申請交出執行權，但並不是一定會交出，依賴於系統的執行緒排程。 因此該方法並不穩定。 class Test { public static void main(String[] args) throws InterruptedException { Te

java多執行緒-Thread的sleep方法

public static native void sleep(long millis) throws InterruptedException; sleep是本地靜態方法。sleep的作用是讓執行緒進入TIME_WAITING狀態，引數是多少毫秒。 class Test { pu

Java——多執行緒的簡單實現

中高階架構師的必經之路： 高可用、高併發、高效能網站開發 多執行緒基本概念： 多個程序同時進 執行緒：排程和執行的單位（cpu的排程） 程序：作為資源分配的單位（作業系統的分配） 執行緒是程序的一部分 使用者執行緒和守護執行緒 使用者執行緒

JAVA多執行緒(一)

要想了解多執行緒,首先需要了解一下多執行緒的基礎知識,如多執行緒生命週期 多執行緒的週期大體上分為五個,NEW,RUNNABLE,RUNNING,BLOCKED,TERMINATED. 在這裡我們首先,先想一個問題,是否執行緒.start之後,該執行緒就執行了呢?

java學習筆記(四) java多執行緒-使用ReentrantLock實現同步

1. 使用ReentrantLock 在JDK1.5中新增的ReentrantLock類在擴充套件功能上比synchronized更加強大，比如具有嗅探鎖定、多路分支通知等功能,使用比synchronized更加靈活。 1.1 使用ReentrantLock實

Java多執行緒之Condition實現原理和原始碼分析（四）

章節概覽、 1、概述 上面的幾個章節我們基於lock(),unlock()方法為入口，深入分析了獨佔鎖的獲取和釋放。這個章節我們在此基礎上，進一步分析AQS是如何實現await，signal功能。其功能上和synchronize的wait，notify一樣。

java 多執行緒 內部類實現

import java.util.concurrent.TimeUnit; /** * InnerThread1 建立了一個擴充套件自Thread 的匿名內部類， * 並且在構造器中建立了一個內部類的一個例項。如果內部類 * 具有你在其他方法中需要訪問的特殊能力

JAVA多執行緒————一篇文章讓你徹底征服多執行緒開發(一)

多執行緒的基本概念 執行緒指程序中的一個執行場景，也就是執行流程，那麼程序和執行緒有什麼區別呢？ 每個程序是一個應用程式，都有獨立的記憶體空間 同一個程序中的執行緒共享其程序中的記憶體和資源（共享的記憶體是堆記憶體和方法區記憶體，棧記憶體不共享，

JAVA多執行緒————一篇文章讓你徹底征服多執行緒開發

多執行緒的基本概念執行緒指程序中的一個執行場景，也就是執行流程，那麼程序和執行緒有什麼區別呢？每個程序是一個應用程式，都有獨立的記憶體空間同一個程序中的執行緒共享其程序中的記憶體和資源（共享的記憶體是堆記憶體和方法區記憶體，棧記憶體不共享，每個執行緒有自己的。）什麼是程序？一

Java多執行緒下載技術實現

多執行緒下載 多執行緒下載技術，簡單的說就是把要下載的檔案分成幾塊，由不同的執行緒來負責每一塊資料的下載任務。 技術要點 RandomAccessFile： Java中用來實現隨機訪問檔案的類 http Range請求頭 具體思路 1、檔案分塊。 檔案分塊大小（blockSize）= （