2. 程式人生 > >深入理解Java多執行緒（三）

深入理解Java多執行緒（三）

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

關於java多執行緒的概念以及基本用法：java多執行緒基礎

3, 執行緒間通訊

執行緒在作業系統中是獨立的個體，經過特殊的處理，執行緒間可以實現通訊，進而成為一個整體，提高CPU利用率

3.1，等待/通知機制

等待：wait()方法作用是使當前執行程式碼的執行緒阻塞，在呼叫wait()之前，執行緒必須獲得該物件的物件級別鎖，即只能在同步方法或同步塊中呼叫wait()方法。執行wait()方法後，當前執行緒會釋放鎖。如果呼叫wait()方法時沒有鎖，那麼會丟擲IllegalMonitorStateException

通知：notify()也要在同步方法或者同步程式碼塊中呼叫，呼叫之前，執行緒也必須獲得該物件的物件級別的鎖，若沒有，則會丟擲IllegalMonitorStateException。該方法用於通知那些可能等待該物件的物件鎖的其他執行緒，如果有多個執行緒等待，則由執行緒規劃器隨機挑選其中一個呈wait狀態的執行緒，對其發出通知，並使它等待獲取該物件的物件鎖。執行notify()方法後，當前執行緒不會馬上釋放該物件鎖，呈wait狀態的執行緒也不能馬上獲取該物件鎖，要等執行notify()方法的執行緒執行完，當前執行緒才會釋放鎖。
方法notifyAll()可以喚醒全部執行緒

新建MyThread1類：

public class MyThread1 extends Thread{
    private Object lock;

    public MyThread1(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized(lock) {
                System.out.println("開始  wait time"
 
+System.currentTimeMillis());
                lock.wait();
                System.out.println("結束  wait time"+System.currentTimeMillis());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

新建MyThread2類：

public class MyThread2 extends Thread{
    private
 
 Object lock;

    public MyThread2(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
            synchronized(lock) {
                System.out.println("開始  notify time"+System.currentTimeMillis());
                lock.notify();
                System.out.println("結束  notify time"+System.currentTimeMillis());
            }
    }
}

測試類：

public class Test {
    public static void main(String[] args) {
        try {
            Object lock = new Object();
            MyThread1 t1 = new MyThread1(lock);
            t1.start();
            Thread.sleep(3000);
            MyThread2 t2 = new MyThread2(lock);
            t2.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

結果：

開始  wait time1534469153084
開始  notify time1534469156084
結束  notify time1534469156084
結束  wait time1534469156084

執行緒t1在執行wait()方法後進入阻塞狀態，3秒後執行緒t2執行，執行了notify()方法後執行緒t2在執行完程式碼塊後喚醒執行緒t1

方法wait(time)的作用是等待一段時間是否有執行緒對鎖進行喚醒，如果超過這個時間就自動喚醒

public class MyRunnable {
    static private Object lock = new Object();
    static private Runnable runnable1 = new Runnable() {

        @Override
        public void run() {
            try {
                synchronized(lock) {
                System.out.println("wait begin timer="+System.currentTimeMillis());
                lock.wait(5000);
                System.out.println("wait end timer="+System.currentTimeMillis());
                } 
            }catch (Exception e) {
                e.printStackTrace();
            }

        }
    };

    public static void main(String[] args) {
        Thread t=  new Thread(runnable1);
        t.start();
    }
}

結果：

wait begin timer=1534473901885
wait end timer=1534473906886
3.2，通過管道進行執行緒間通訊：位元組流

Java語言裡提供了很多的輸入/輸出流Stream,便於資料讀寫，pipeStream（管道流）是一種特殊的流，用於在不同執行緒間直接傳送資料，一個執行緒傳送資料到輸出管道，另一個執行緒從輸入管道中讀取資料，可以實現執行緒間的通訊
Java的JDK提供了4個類

  • 位元組流：PipedInputStream和PipedOutPutStream
  • 字元流：PipedReader和PipedWriter

先看看位元組流：
新建WriteData類：

public class WriteData {
    public void writeMethod(PipedOutputStream out) {
        try {
            System.out.println("write: ");
            for(int i=0;i<20;i++) {
                String outData = ""+(i+1);
                out.write(outData.getBytes());
                System.out.print(outData);
            }
            System.out.println();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

新建ReadData類：

public class ReadData {
    public void readMethod(PipedInputStream input) {
        try {
            System.out.println("read: ");
            byte[] byteArray = new byte[20];
            int readLength = input.read(byteArray);
            while (readLength!=-1) {
                String newData = new String(byteArray,0,readLength);
                System.out.print(newData);
                readLength = input.read(byteArray);
                }
            System.out.println();
            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

新建兩個執行緒：

public class ThreadWrite extends Thread{

    private WriteData write;
    private PipedOutputStream out;

    public ThreadWrite(WriteData write, PipedOutputStream out) {
        super();
        this.write = write;
        this.out = out;
    }

    @Override
    public void run() {
        write.writeMethod(out);
    }
}
public class ThreadRead extends Thread{

    private ReadData read;
    private PipedInputStream input;

    public ThreadRead(ReadData read, PipedInputStream input) {
        super();
        this.read = read;
        this.input = input;
    }

    @Override
    public void run() {
        read.readMethod(input);
    }
}

測試類：

public class Run {

    public static void main(String[] args) {
        try {
            WriteData writeData = new WriteData();
            ReadData readData = new ReadData();

            PipedInputStream inputStream =new PipedInputStream();
            PipedOutputStream outputStream = new PipedOutputStream();

            //inputStream.connect(outputStream);
            outputStream.connect(inputStream);

            ThreadRead threadRead = new ThreadRead(readData, inputStream);
            threadRead.start();

            Thread.sleep(2000);

            ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);
            threadWrite.start();
        } catch (IOException e) {
            e.printStackTrace();
        }catch(InterruptedException e1) {
            e1.printStackTrace();
        }
    }
}

結果：

read: 
write: 
1234567891011121314151617181920
1234567891011121314151617181920

再看看字元流：
WriteData類:

public class WriteData {
    public void writeMethod(PipedWriter out) {
        try {
            System.out.println("write: ");
            for(int i=0;i<20;i++) {
                String outData = ""+(i+1);
                out.write(outData);
                System.out.print(outData);
            }
            System.out.println();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ReadData類：

public class ReadData {
    public void readMethod(PipedReader input) {
        try {
            System.out.println("read: ");
            char[] byteArray = new char[20];
            int readLength = input.read(byteArray);
            while (readLength!=-1) {
                String newData = new String(byteArray,0,readLength);
                System.out.print(newData);
                readLength = input.read(byteArray);
                }
            System.out.println();
            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

兩個執行緒類：

public class ThreadRead extends Thread{

    private ReadData read;
    private PipedReader input;

    public ThreadRead(ReadData read, PipedReader input) {
        super();
        this.read = read;
        this.input = input;
    }

    @Override
    public void run() {
        read.readMethod(input);
    }
}

public class ThreadWrite extends Thread{

    private WriteData write;
    private PipedWriter out;

    public ThreadWrite(WriteData write, PipedWriter out) {
        super();
        this.write = write;
        this.out = out;
    }

    @Override
    public void run() {
        write.writeMethod(out);
    }
}

測試類：

public class Run {

    public static void main(String[] args) {
        try {
            WriteData writeData = new WriteData();
            ReadData readData = new ReadData();

            PipedReader inputStream =new PipedReader();
            PipedWriter outputStream = new PipedWriter();

            //inputStream.connect(outputStream);
            outputStream.connect(inputStream);

            ThreadRead threadRead = new ThreadRead(readData, inputStream);
            threadRead.start();

            Thread.sleep(2000);

            ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);
            threadWrite.start();
        } catch (IOException e) {
            e.printStackTrace();
        }catch(InterruptedException e1) {
            e1.printStackTrace();
        }
    }
}

結果：

read: 
write: 
1234567891011121314151617181920
1234567891011121314151617181920
3.2，方法join的使用

很多時候，主執行緒建立並啟動子執行緒，子執行緒要進行一些耗時的計算，主執行緒往往早於子執行緒結束，如果主執行緒想等待子執行緒結束，則需要join()方法

新建MyThread類：

public class MyThread extends Thread{

    @Override
    public void run() {
        try {
            int secondValue = (int)(Math.random()*1000);
            System.out.println(secondValue);
            Thread.sleep(secondValue);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

測試類：

public class Test {

    public static void main(String[] args) {
        try {
            MyThread threadTest = new MyThread();
            threadTest.start();
            threadTest.join();
            System.out.println("我要等子執行緒結束再開始");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

結果：

231
我要等子執行緒結束再開始

join()方法的作用是使所屬執行緒物件正常執行run（）方法，使當前主執行緒處於阻塞狀態，等子執行緒結束後再執行主執行緒，join在內部使用wait（）方法進行等待

方法join(time)和sleep(time)的區別？
這兩個方法都會等待time時間再執行，但是在同步的處理上是不一樣的
join(time)的功能是在內部使用wait(time)方法，所以join方法其實會釋放鎖，
join原始碼：

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

在執行join(time)方法後，當前執行緒的鎖被釋放，此時其他執行緒可以呼叫此執行緒的同步方法，而sleep（time）方法則不會釋放鎖

3.3，類ThreadLocal的使用

ThreadLocal為變數在每個執行緒中都建立了一個副本，所以每個執行緒都可以訪問自己內部的副本變數

新建Tools類：

public class Tools {

    public static ThreadLocal t1 = new ThreadLocal();
}

兩個執行緒類：

public class ThreadA extends Thread{

    @Override
    public void run() {
        try {
            for(int i=0;i<10;i++) {
                Tools.t1.set("ThreadA"+(i+1));
                System.out.println("ThreadA get Value="+Tools.t1.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }   
}
public class ThreadB extends Thread{

    @Override
    public void run() {
        try {
            for(int i=0;i<10;i++) {
                Tools.t1.set("ThreadB"+(i+1));
                System.out.println("ThreadB get Value="+Tools.t1.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }   
}

測試類：

public class Run {

    public static void main(String[] args) {
        try {
            ThreadA a = new ThreadA();
            ThreadB b = new ThreadB();
            a.start();
            b.start();
            for(int i=0;i<10;i++) {
                Tools.t1.set("Main"+(i+1));
                System.out.println("Main get Value="+Tools.t1.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

結果：

Main get Value=Main1
ThreadA get Value=ThreadA1
ThreadB get Value=ThreadB1
ThreadB get Value=ThreadB2
ThreadA get Value=ThreadA2
Main get Value=Main2
Main get Value=Main3
ThreadB get Value=ThreadB3
ThreadA get Value=ThreadA3
Main get Value=Main4
ThreadB get Value=ThreadB4
ThreadA get Value=ThreadA4
ThreadB get Value=ThreadB5
ThreadA get Value=ThreadA5
Main get Value=Main5
Main get Value=Main6
ThreadA get Value=ThreadA6
ThreadB get Value=ThreadB6
ThreadB get Value=ThreadB7
ThreadA get Value=ThreadA7
Main get Value=Main7
ThreadB get Value=ThreadB8
Main get Value=Main8
ThreadA get Value=ThreadA8
Main get Value=Main9
ThreadA get Value=ThreadA9
ThreadB get Value=ThreadB9
Main get Value=Main10
ThreadB get Value=ThreadB10
ThreadA get Value=ThreadA10

由結果可以看到有雖然有3個執行緒set（）資料值但是每個執行緒都能取出屬於自己的資料

3.4，類InheritableThreadLocal的使用

使用InheritableThreadLocal類可以在子執行緒中取得父執行緒繼承下來的值
如果在子執行緒取得值的同時，主執行緒將InheritableThreadLocal中的值進行更改，那麼子執行緒取到的值還是舊值

相關推薦

深入理解Java多執行緒（三）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 3, 執行緒間通訊 執行緒在作業系統中是獨立的個體，經過特殊的處理，執行緒間可以實現通訊，進而成為一個整體，提高CPU利用率 3.1，等待/通知機制 等待：wait()方法作用是使當前執

深入理解java多執行緒（六）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 6，單例模式與多執行緒 如何使單例模式遇到多執行緒是安全的這是下面要討論的內容 6.1，立即載入 立即載入就是在使用類的時候已經將物件建立完畢，例如String s = new Stri

深入理解Java多執行緒（五）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 5，定時器Timer JDK中Timer類主要是負責計劃任務的功能，也就是在指定的時間開始執行某一個任務，封裝任務的類是TimerTask類，執行計劃任務的程式碼要放進TimerTask的子類，因為它一個抽象

深入理解Java多執行緒（四）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 4，Lock的使用 ReentrantLook類的使用 ReentrantReadWriteLock類的使用 4.1，ReentrantLook類的使用 新建MySe

深入理解Java多執行緒（二）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 2，多執行緒的同步 多個執行緒對同一物件的變數進行同時訪問時會引發執行緒的安全問題，即一個執行緒對一個變數修改後，其他執行緒可能會讀取到修改後的變數值，所以我們要對獲得的例項變數的值進行同步處理，保證其原子性

深入理解Java多執行緒（一）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 1，停止執行緒 停止執行緒意味著線上程執行完之前停止正在做的操作，即立刻放棄當前的操作，這並不容易。停止執行緒可以用Thread.stop()方法，但是這個方法不安全，所以不建議使用，還有一個方法就是Thre

java 多執行緒（三）

1、java 中任何物件都可以作為鎖 2、同步程式碼執行完成後會自動釋放掉 3、happend-before 4、類鎖和物件鎖相互幾乎不影響，不存在競爭 5、私有鎖和物件鎖不存在競爭，相互不影響 6、一個執行緒一旦呼叫wait()就釋放了所以的鎖，一個等待執行緒被notify()喚醒，不會立刻進入喚

Java 多執行緒（三）—— 執行緒的生命週期及方法

這篇部落格介紹執行緒的生命週期。 　　執行緒是一個動態執行的過程，它也有從建立到死亡的過程。 執行緒的幾種狀態 在 Thread 類中，有一個列舉內部類： 上面的資訊以圖片表示如下： 　　第一張圖：  第二張圖：把等待、計時等待、阻塞看成阻塞一個狀態了 1、新建狀態（ne

JAVA多執行緒（三）

多執行緒三 執行緒優先順序 使用者執行緒與守護執行緒 執行緒同步 執行緒通訊 用到的程式碼後面會新增上去，如果急需要的話，評論留下郵箱 執行緒優先順序 （1）每個執行緒都有優先順序，優先順序越高，獲

Java多執行緒（三）、執行緒同步

在之前，已經學習到了執行緒的建立和狀態控制，但是每個執行緒之間幾乎都沒有什麼太大的聯絡。可是有的時候，可能存在多個執行緒多同一個資料進行操作，這樣，可能就會引用各種奇怪的問題。現在就來學習多執行緒對資料訪問的控制吧。  由於同一程序的多個執行緒共享同一片儲存空間，在帶來方便

Java多執行緒（三）：Synchronized

多執行緒安全 髒讀：多個執行緒對同一個物件的例項變數進行修改後訪問，導致讀到的資料是被修改過的。 例項 ThreadDomain16類 public class ThreadDomain16 { private int num = 0; public void addNum(String u

Java多執行緒（三）：volatile

volatile volatile是一種輕量同步機制。請看例子 MyThread25類 public class MyThread25 extends Thread{ private boolean isRunning = true; public boolean isRunning()

深入理解Java多執行緒--執行緒池（ThreadPool）

在java多執行緒開發中，我們需要使用執行緒的時候一般是建立一個Thread物件，然後呼叫start（）方法去執行執行緒操作。這樣做沒有什麼問題，但是如果我們有很多工需要多個執行緒來非同步執行的時候，在我們建立了很多執行緒的情況下，會造成很大的效能方面的問題。 1.大量的執行緒的建立和銷燬，

深入理解系列之JAVA多執行緒（2）——synchronized同步原理

多執行緒中為了解決執行緒安全問題，一個重要的手段就是同步！所謂同步其實就是使得原本各個執行緒交叉執行（非同步），變成排隊執行（同步）。同步策略使得不同執行緒操作共享資料遵循“先來後到“，從而避免某個執行緒沒有處理完資料就被另一執行緒搶佔操作出現資料被覆蓋或

java多執行緒（六）深入理解volitale關鍵字

一、java記憶體模型與多執行緒程式設計中的三個感念 1、原子性 原子性是指一些操作或者全都執行，要麼或者全都不執行，整個操作作為一個整體是不可分割的，例如，一個銀行中有兩個賬戶A，B，現在要從A賬戶中轉賬500元到B賬戶，那麼一共可以分為兩個步驟：

java多執行緒（二）:建立執行緒的三種方式以及優缺點總結

一、Java中建立執行緒主要有三種方式： 1、繼承Thread類建立執行緒類 步驟： （1）定義Thread類的子類，並重寫該類的run方法，該run方法的方法體就代表了執行緒要完成的任務。因此把run()方法稱為執行體。 （2）建立Thread子類的例項，即建立了執行緒物件。

併發程式設計之美，帶你深入理解java多執行緒原理

1.什麼是多執行緒？ 多執行緒是為了使得多個執行緒並行的工作以完成多項任務，以提高系統的效率。執行緒是在同一時間需要完成多項任務的時候被實現的。 2.瞭解多執行緒 瞭解多執行緒之前我們先搞清楚幾個重要的概念！ 如上圖所示：對我們的專案有一個主記憶體，這個主記憶體裡面存放了我們的共享變數、方法區、堆中的物件等

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

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

JAVA基礎23-多執行緒（三）【synchronized，ReentranLock，volatile、死鎖】

一、同步         大多數多執行緒應用中，兩個或兩個以上的執行緒需要共享對同一資料的存取，此時出現多個程式交替處理該資料，從而導致資料出現訛誤。 9-1.Synchronized關鍵字       &nb

Java多執行緒（六）之Deque與LinkedBlockingDeque深入分析

1、LinkedBlockingDeque資料結構 雙向併發阻塞佇列。所謂雙向是指可以從佇列的頭和尾同時操作，併發只是執行緒安全的實現，阻塞允許在入隊出隊不滿足條件時掛起執行緒，這裡說的佇列是指支援FIFO/FILO實現的連結串列。 首先看下LinkedBlockingDeque的資料結構。通常情況