Java多執行緒筆記

CooperMiNi 發表於 2021-08-25
Java

介紹

程式(program)是為完成特定任務、用某種語言編寫的一組指令的集合。即指一段靜態的程式碼,靜態物件。
程式(process)是程式的一次執行過程,或是正在執行的一個程式。是一個動態的過程:有它自身的產生、存在和消亡的過程。——生命週期
  >如:執行中的QQ,執行中的MP3播放器
  >程式是靜態的,程式是動態的
  >程式作為資源分配的單位,系統在執行時會為每個程式分配不同的記憶體區域
執行緒(thread),程式可進一步細化為執行緒,是一個程式內部的一條執行路徑。若一個程式同一時間並行執行多個執行緒,就是支援多執行緒的執行緒作為排程和執行的單位,每個執行緒擁有獨立的執行棧和程式計數器(pc),執行緒切換的開銷小;
一個程式中的多個執行緒共享相同的記憶體單元/記憶體地址空間→它們從同一堆中分配物件,可以訪問相同的變數和物件。這就使得執行緒間通訊更簡便、高效。但多個執行緒操作共享的系統資源可能就會帶來安全的隱患。

為什麼需要多執行緒

眾所周知,CPU、記憶體、I/O 裝置的速度是有極大差異的,為了合理利用 CPU 的高效能,平衡這三者的速度差異,計算機體系結構、作業系統、編譯程式都做出了貢獻。

執行緒狀態轉換

Java多執行緒筆記

新建(New)

建立後尚未啟動。

就緒(Runnable)

可能正在執行,也可能正在等待 CPU 時間片。

包含了作業系統執行緒狀態中的 Running 和 Ready。

阻塞(Blocking)

等待獲取一個排它鎖,如果其執行緒釋放了鎖就會結束此狀態。

無限期等待(Waiting)

等待其它執行緒顯式地喚醒,否則不會被分配 CPU 時間片。

限期等待(Timed Waiting)

無需等待其它執行緒顯式地喚醒,在一定時間之後會被系統自動喚醒。

呼叫 Thread.sleep() 方法使執行緒進入限期等待狀態時,常常用“使一個執行緒睡眠”進行描述。

呼叫 Object.wait() 方法使執行緒進入限期等待或者無限期等待時,常常用“掛起一個執行緒”進行描述。

睡眠和掛起是用來描述行為,而阻塞和等待用來描述狀態。

阻塞和等待的區別在於,阻塞是被動的,它是在等待獲取一個排它鎖。而等待是主動的,通過呼叫 Thread.sleep() 和 Object.wait() 等方法進入。

死亡(Terminated)

可以是執行緒結束任務之後自己結束,或者產生了異常而結束。

執行緒使用方式

有三種使用執行緒的方法:

  • 實現 Runnable 介面;
  • 實現 Callable 介面;
  • 繼承 Thread 類。

實現 Runnable 和 Callable 介面的類只能當做一個可以線上程中執行的任務,不是真正意義上的執行緒,因此最後還需要通過 Thread 來呼叫。可以說任務是通過執行緒驅動從而執行的。

繼承 Thread 類

public class ThreadTest {
    /**
     * 多執行緒的建立,
     * 方式一:
     * 1.繼承與Thread類
     * 2.重寫Thread類的run方法->將此執行緒執行的操作宣告在run中
     * 3.建立Thread類的子類
     * 4.通過此物件呼叫start
     */
    public static void main(String[] args) {
//        建立Thread類的子類的物件
        MyThread t1 = new MyThread();
        //不能通過run方法開啟執行緒,因為還會在主執行緒中執行,應該使用start方法開啟執行緒
        //不能通過呼叫兩次start方法來開啟兩個子執行緒
        t1.start();

        //可以通過再建立一個物件來實現

        for (int i=0;i<1000;i++){
            if (i%2!=0){
                System.out.println(i+"****");
            }
        }
    }

}
class MyThread extends Thread{
    @Override
    public void run() {
       for (int i=0;i<1000;i++){
           if (i%2==0){
               System.out.println(i);
           }
       }
    }
}

  

    /**
     * 方式二:
     * 匿名子類建立,針對只呼叫一次的執行緒
     */
    public static void main(String[] args) {

        MyThread1 myThread1 = new MyThread1();
        myThread1.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();

        //通過匿名子類實現呼叫:特點只需要呼叫一次的子執行緒
        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<1000;i++){
                    if (i%3==0){
                        System.out.println(Thread.currentThread().getName()+"***"+i);
                    }
                }
            }
        }.start();
    }

}

class MyThread1 extends Thread{
    @Override
    public void run() {
       for (int i=0;i<100;i++){
           if (i%2!=0){
               System.out.println(Thread.currentThread().getName()+"***"+i);

           }
       }
    }
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+"***"+i);
            }
        }
    }
}

實現 Runnable 介面

package com.atguigu.juc.runnable;

/**
 * 建立多執行緒方式Runnable
 * 1.建立一個實現Runnable介面的類
 *
 * 2.實現類去實現Runnable中的抽象方法: run( )
 *
 * 3.建立實現類的物件
 *
 * 4、將此物件作為引數傳遞到Thread類的構造器中,建立Thread類的物件
 *
 * 5,通過Thread類的物件呼叫start()
 */

public class TestThread {
    public static void main(String[] args) {
        //3.建立實現類的物件
        MyThread myThread = new MyThread();
        //4、將此物件作為引數傳遞到Thread類的構造器中,建立Thread類的物件
        Thread t1 = new Thread(myThread);
        //5,通過Thread類的物件呼叫start()
        t1.start();
    }
}
//1.建立一個實現Runnable介面的類
class MyThread implements Runnable{
//2.實現類去實現Runnable中的抽象方法: run( )
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}

   

實現 Callable 介面

 

執行緒常見方法

package com.atguigu.juc.tset01;

/**
 * 1.yield():釋放當前cpu的執行權
 *
 * 2.start():啟動當前執行緒;呼叫當前執行緒的run()
 *
 * 3.run():通常需要重寫Thread類中的此方法,將建立的執行緒要執行的操作宣告在此方法中
 *
 * 4.getName()∶獲取當前執行緒的名字
 *
 * 5.setName():設定當前執行緒的名字
 *
 * 6.currentThread():靜態方法,返回執行當前程式碼的執行緒
 *
 * 7.join():線上程a中呼叫執行緒b的join(),此時執行緒a就進入阻塞狀態,直到執行緒b完全執行完以後,執行緒a才結束阻塞狀態。
 *
 * 8.sleep():讓當前執行緒"睡眠”指定的毫秒。在指定的毫秒時間內,當前執行緒是阻塞狀態。
 *
 */
public class MyThreatTest {
    public static void main(String[] args) {


        TestMyThread t1 = new TestMyThread();
            t1.start();
        new Thread(){
            @Override
            public void run(){
                for (int i=0;i<100;i++){
                    if (i%2==0){
                        try {
                            sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "子執行緒" + i);
                        yield();
                    }

                }
            }
        }.start();

        for (int i=0;i<100;i++){
            if (i%3==0){
                System.out.println(Thread.currentThread().getName() + "main方法" + i);
            }
            if (i==20){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class TestMyThread extends Thread{
    @Override
    public void run(){
        for (int i=0;i<100;i++){
            if (i%5==0){
                System.out.println(Thread.currentThread().getName() + "2222222222222子執行緒" + i);

            }

        }
    }
}

  

synchronized鎖機制

  • 一把鎖只能同時被一個執行緒獲取,沒有獲得鎖的執行緒只能等待;
  • 每個例項都對應有自己的一把鎖(this),不同例項之間互不影響;例外:鎖物件是*.class以及synchronized修飾的是static方法的時候,所有物件公用同一把鎖
  • synchronized修飾的方法,無論方法正常執行完畢還是丟擲異常,都會釋放鎖

同步程式碼---Runnable介面方式

/**
 *方式一:同步程式碼塊
 * synchronized(同步監視器){
 *          //需要被同步的程式碼
 *  }
 * 說明:
 * 1.操作共享資料的程式碼,即為需要被同步的程式碼
 * 2.共享資料:多個執行緒共同操作的變數
 * 3.同步監視器,俗稱:鎖。任何一個類的物件都可以作為索
 * 4.在Java中,我們通過同步機制,來解決執行緒的安全問題。
 * 補充:在實現Runnable介面建立多執行緒的方式中,我們可以考慮使用this充當同步監視器。
 * 方式二:同步方法
 *  如果操作共享資料的程式碼完整的宣告在一個方法中,我們不妨將此方法宣告同步的。
 * 5.同步的方式,解決了執行緒的安全問題。---好處
 * 操作同步程式碼時,只能有一個執行緒參與,其他執行緒等待。相當於是一個單執行緒的過程,效率低。
 */
public class WindowToRunnable {
    public static void main(String[] args) {
        Window2 window2 = new Window2();

        Thread t1 = new Thread(window2);
        Thread t2 = new Thread(window2);
        Thread t3 = new Thread(window2);

        t1.setName("視窗1");
        t2.setName("視窗2");
        t3.setName("視窗3");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 implements Runnable{
//這裡不用加static,因為呼叫的物件只有一個
    private  int ticket=100;
    @Override
    public void run() {

            while (true) {
                synchronized (this.getClass()){
                if (ticket > 0) {
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                    System.out.println(Thread.currentThread().getName() + "買票,票號:" + ticket);
                    ticket--;
                }
            }
        }
    }
}

  同步方法--Runnable介面方法

package com.atguigu.juc.bookPage;

/**
 * 使用同步方法解決實現Runnable介面的執行緒安全問題
 * 關於同步方法的總結:
 * 1.同步方法仍然涉及到同步監視器,只是不需要我們顯式的宣告。
 * 2.非靜態的同步方法,同步監視器是: this
 * 靜態的同步方法,同步監視器是:當前類本身
 */

public class WindowExtSynn {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("視窗1");
        w2.setName("視窗2");
        w3.setName("視窗3");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Window4 extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
            show();

        }
    }

    private static synchronized void show() {
        if (ticket>0){

            System.out.println(Thread.currentThread().getName()+":買票:票號為"+ticket);
            ticket--;
        }
    }
}

  同步方法---繼承方法

package com.atguigu.juc.bookPage;

/**
 * 使用同步方法解決實現Runnable介面的執行緒安全問題
 * 關於同步方法的總結:
 * 1.同步方法仍然涉及到同步監視器,只是不需要我們顯式的宣告。
 * 2.非靜態的同步方法,同步監視器是: this
 * 靜態的同步方法,同步監視器是:當前類本身
 */

public class WindowExtSynn {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("視窗1");
        w2.setName("視窗2");
        w3.setName("視窗3");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Window4 extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
            show();

        }
    }

    private static synchronized void show() {
        if (ticket>0){

            System.out.println(Thread.currentThread().getName()+":買票:票號為"+ticket);
            ticket--;
        }
    }
}

  死鎖

示例:兩個執行緒都拿到第一層鎖的key,然後都需要第二層鎖的key,但key在對方手中,而方法沒有執行完,都不可能釋放key,互相僵持。

import static java.lang.Thread.sleep;

public class TestSyn {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){
            @Override
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }

            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

  Lock鎖機制

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解決執行緒安全問題的方式三: Lock鎖--- JDK5.0新增
 *
 * synchronized 與Lock的異同?
 * 相同:二者都可以解決執行緒安全問題
 * 不同: synchronized機制在執行完相應的同步程式碼以後,自動的釋放同步監視器
 *      Lock需要手動的啟動同步(Lock() ),同時結束同步也需要手動的實現(unlock())
 *
 */
public class LockTest {
    public static void main(String[] args) {
        Window6 window6 = new Window6();
        Thread t1 = new Thread(window6);
        Thread t2 = new Thread(window6);
        Thread t3 = new Thread(window6);

        t1.setName("視窗1");
        t2.setName("視窗2");
        t3.setName("視窗3");

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

    }
}
class Window6 implements Runnable{
    private int ticker=100;

    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if (ticker>0){
                    System.out.println(Thread.currentThread().getName()+"買票:票號:"+ticker);

                    ticker--;
                }else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

  銀行有一個賬戶。有兩個儲戶分別向同一個賬戶存3000元,每次存1e00,存3次。每次存完列印賬戶餘額。

/**
 * 銀行有一個賬戶。
 * 有兩個儲戶分別向同一個賬戶存3000元,每次存1e00,存3次。每次存完列印賬戶餘額。
 * 分析:
 * 1.是否是多執行緒問題?是,兩個儲戶執行緒
 * 2.是否有共享資料?有,賬戶(或賬戶餘額).
 * 3.是否有執行緒安全問題?有
 * 4.需要考慮如何解決執行緒安全問題?同步機制:有三種方式。
 */
public class AccountTest {

    public static void main(String[] args) {
        Account account = new Account(0);
        Customer c1 = new Customer(account);
        Customer c2 = new Customer(account);
        c1.setName("A");
        c2.setName("B");
        c1.start();
        c2.start();
    }
}
class Account{
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }
    //存錢
    public synchronized void deposit(double amt){
        //synchronized (this.getClass()) {
            if (amt>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                balance+=amt;
                System.out.println(Thread.currentThread().getName()+"存錢成功,餘額為"+balance);
            }
       // }
    }
}
class Customer extends Thread{
    private Account acc;
    public Customer(Account acc){
        this.acc=acc;
    }

    @Override
    public void run() {
        for (int i=0;i<30;i++){
            acc.deposit(1000);
        }
    }
}

  

A存錢成功,餘額為1000.0
B存錢成功,餘額為2000.0
B存錢成功,餘額為3000.0
B存錢成功,餘額為4000.0
A存錢成功,餘額為5000.0
A存錢成功,餘額為6000.0