執行緒介紹
- 行程
- 執行緒
- - 單、多執行緒
  - 并發和并行
執行緒的使用
- 創建執行緒的兩種方法
- 機制說明
- 舉例說明（繼承Thread類重寫run（）方法實作執行緒）
- 為什么呼叫start（）不直接呼叫run（）方法？
- 舉例（實作Runnable介面實作執行緒）
- 繼承Thread和Runnable介面對比
- 售票系統（出現了超票問題，該怎么解決）
- 執行緒終止
執行緒的常用方法
- 第一組
- 第二組
- 例子
- 用戶執行緒和守護執行緒
- - 如何將執行緒設定為守護執行緒
執行緒的生命周期
Synchronized（行程同步機制）
- 同步具體方法-Synchronized
- 使用Synchronized解決售票問題
- - 代碼塊上加鎖
  - 方法上加鎖
互斥鎖
- 基本介紹
- 注意事項
- - 錯誤示范（鎖物件不同）
執行緒死鎖
釋放鎖和不釋放鎖情況
本章作業

執行緒介紹

在這里插入圖片描述

行程

在這里插入圖片描述

執行緒

在這里插入圖片描述

單、多執行緒

1.單執行緒:同一個時刻，只允許執行一個執行緒
2.多執行緒:同一個時刻，可以執行多個執行緒，比如:一個qq行程,可以同時打開多個聊天視窗,一個迅雷行程，可以同時下載多個檔案

并發和并行

在這里插入圖片描述

執行緒的使用

創建執行緒的兩種方法

在java中執行緒來使用有兩種方法，
1.繼承Thread類,重寫run方法
2.實作Runnable介面，重寫run方法

機制說明

在這里插入圖片描述

當main執行緒通過start()方法啟動一個子執行緒Thread-0，并不代表主執行緒會阻塞，它會繼續執行，并且與子執行緒交替執行
主執行緒結束但是任有子執行緒不會造成應用程式的結束
主執行緒可以開多個子執行緒，子執行緒也能開新的子執行緒
在這里插入圖片描述

舉例說明（繼承Thread類重寫run（）方法實作執行緒）

創建一個行程每隔一秒輸出內容，輸出8次后停止

package Threaduse;
//演示通過繼承Thread 類創建執行緒
public class Test {
    public static void main(String[] args) {
        //創建Cat物件，可以當做執行緒使用
        cat cat = new cat();
        cat.start();//啟動執行緒-> 最侄訓執行cat的run方法
    }
}
//1. 當一個類繼承了 Thread 類， 該類就可以當做執行緒使用
//2. 我們會重寫 run方法，寫上自己的業務代碼
//3. run Thread 類 實作了 Runnable 介面的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class cat extends Thread{
    //重寫run（）方法

    @Override
    public void run() {//在這里寫上自己要實作的業務邏輯
        super.run();
        int times=0;
        while(true){
            System.out.println("熊貓燒香"+times++);
            //休眠一秒鐘(一毫秒為單位)，拋出例外ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times==8){
                break;
            }
        }
    }
}

為什么呼叫start（）不直接呼叫run（）方法？

cat.run()//是一個普通方法，由主執行緒直接呼叫run（）方法，無法實作執行緒
cat.start()//啟動執行緒，最侄訓執行cat.run()方法
在這里插入圖片描述

start（）方法原始碼解讀：
run（）方法何時執行取決于CPU

舉例（實作Runnable介面實作執行緒）

說明

java是單繼承的，在某些情況下一個類可能已經繼承了某個父類,這時在用繼承Thread類方法來創建執行緒顯然不可能了，
java設計者們提供了另外一個方式創建執行緒,就是通過實作Runnable介面來創建執行緒

深入內容到之后再講，先介紹怎么實作

package Threaduse;

public class Thread02 {
    public static void main(String[] args) {
        //底層使用了代理模式（一種設計模式）
        Dog dog = new Dog();
        Thread thread = new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable {

    @Override
    public void run() {
        //設定自己想設計的邏輯
        int num=0;
        while(true){
            System.out.println("熊貓燒香"+(++num)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(num==8){
                break;
            }
        }
    }
}

繼承Thread和Runnable介面對比

在這里插入圖片描述

售票系統（出現了超票問題，該怎么解決）

在這里插入圖片描述

package Threaduse;

public class SellTicketSystem {
    public static void main(String[] args) {
        //使用Thread實作執行緒
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();
        //使用Runnable介面
        SellTicket02 sellTicket02 = new SellTicket02();
        Thread thread = new Thread(sellTicket02);
        Thread thread2 = new Thread(sellTicket02);
        Thread thread3 = new Thread(sellTicket02);
        thread.start();
        thread2.start();
        thread3.start();
    }
}
class SellTicket01 extends Thread {
    private static int nums=100;
    @Override
    public void run() {
        while(true){
            if(nums<=0){
                System.out.println("票賣完了");
                break;
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("售票口"+Thread.currentThread().getName()+"賣出一張票"+"剩余票數"+(nums--));
        }
    }
}
class SellTicket02 implements Runnable {
private int nums=100;//這里不用定義static，因為始終使用的是同一個SellTicket02生成的物件
    @Override
    public void run() {
        while(true){
            if(nums<=0){
                System.out.println("票賣完了");
                break;
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("售票口"+Thread.currentThread().getName()+"賣出一張票"+"剩余票數"+(nums--));
        }
    }
}

執行緒終止

●基本說明
1.當執行緒完成任務后,會自動退出，
2.還可以通過使用變數來控制run方法退出的方式停止執行緒，即通知方式
在這里插入圖片描述

package Threaduse;

public class StopThread {
    public static void main(String[] args) throws InterruptedException {
        //需求:啟動一個執行緒t，要求在main執行緒中去停止執行緒t,請編程實作.
        如果希望main執行緒去控制t1 執行緒的終止，必須可以修改 loop
        // 讓t1 退出run方法，從而終止t1執行緒->通知方式
        讓主執行緒休眠10秒，再通知和執行緒退出
        T t = new T();
        t.start();
        Thread.sleep(10000);
        t.setLoop(false);
    }
}
class T extends Thread {
    private boolean loop=true;
    @Override
    public void run() {
        while(loop){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("執行緒在運行");
        }
    }
    public void setLoop(boolean b){
        loop=b;
    }
}

執行緒的常用方法

第一組

1.setName /設定執行緒名稱，使之與引數name相同
2.getName//回傳該執行緒的名稱
3. start//使該執行緒開始執行;Java虛擬機底層呼叫該執行緒的start()方法
4. run//呼叫執行緒物件run方法;
5. setPriority //更改執行緒的優先級
6.getPriority//獲取執行緒的優先級
7.sleep//在指定的毫秒數內讓當前正在執行的執行緒休眠(暫停執行)
8. interrupt //中斷執行緒,但沒有結束執行緒，所以一般用于中斷休眠的執行緒

執行緒的優先級范圍：
public static final int MIN_PRIORITY=1;
public static final int NORM_PRIORITY=5;
public static final int MAX_PRIORITY=10;

package Threaduse;

import javax.crypto.spec.PSource;

public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        //利用主執行緒設定子執行緒名，并中斷正在休眠的執行緒
        Z z = new Z();
        z.setName("張李浩");//設定執行緒名
        z.setPriority(Thread.MIN_PRIORITY);
        z.start();
        //主執行緒在輸出5個i后，interrupt子執行緒
        for(int i=0;i<5;i++){
            Thread.sleep(1000);
            System.out.println(i);
        }
        z.interrupt();
    }
}
class Z extends Thread {
    @Override
    public void run() {
    //先輸出，休眠50秒，interrupt，然后再輸出
        while(true){
            int nums=0;
            for(int i=0;i<10;i++){
                System.out.println("執行緒"+Thread.currentThread().getName()+"正在運行"+(++nums));
            }
            try {
                System.out.println("執行緒正在休眠");
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                System.out.println("執行緒被打斷了");
            }
        }
    }
}

第二組

yield()執行緒禮讓，假如CPU充足則不一定成功
join()執行緒插隊
在這里插入圖片描述

例子

在這里插入圖片描述

package Threaduse;

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        person person = new person();
        Thread thread = new Thread(person);
        //主執行緒每個一秒，輸出hi，共10次
        for(int i=1;i<=10;i++){
            Thread.sleep(1000);
            System.out.println("hi"+i);
            if(i==5){
                //啟動子執行緒，讓其執行完再運行主執行緒
                thread.start();
                thread.join();
            }
        }
        System.out.println("主執行緒結束");
    }
}
class person implements Runnable {
    @Override
    public void run() {
        while(true){
            for(int i=1;i<=10;i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("hello"+i);
            }
            System.out.println("子執行緒結束");
            break;
        }
    }
}

用戶執行緒和守護執行緒

1.用戶執行緒:也叫作業執行緒，當執行緒的任務執行完或通知方式結束
2守護執行緒:一般是為作業執行緒服務的，當所有的用戶執行緒結束，守護執行緒自動結束
3.常見的守護執行緒:垃圾回識訓制

如何將執行緒設定為守護執行緒

守護執行緒當所以用戶現場結束，守護執行緒也自動結束
mydaemoThread.setDaemo(true);//設為守護執行緒

package com.hspedu.method;

/**
 * @author 韓順平
 * @version 1.0
 */
public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我們希望當main執行緒結束后，子執行緒自動結束
        //,只需將子執行緒設為守護執行緒即可
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();

        for( int i = 1; i <= 10; i++) {//main執行緒
            System.out.println("寶強在辛苦的作業...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        for (; ; ) {//無限回圈
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("馬蓉和宋喆快樂聊天，哈哈哈~~~");
        }
    }
}

執行緒的生命周期

細分7種，總的來說6種，都對
執行緒狀態，執行緒可以處于以下6種狀態之一:
NEW
尚未的執行緒處于此狀態，
RUNNABLE（RUNNABLE狀態可以細分為Ready和Running兩種狀態------>七種）
在Java虛擬機中執行的執行緒處于此狀態，
BLOCKED
被阻塞等待監視器鎖定的執行緒處于此狀態，
WAITING
正在等待另一個執行緒執行特定動作的執行緒處于此狀態，
TIMED_WAITING
正在等待另一個執行緒執行動作達到指定等待時間的執行緒處于此狀態，
TERMINATED
已退出的執行緒處于此狀態，
在這里插入圖片描述

Synchronized（行程同步機制）

1.在多執行緒編程，一些敏感資料不允許被多個執行緒同時訪問，此時就使用同步訪問技術，
保證資料在任何同一時刻，最多有一個執行緒訪問，以保證資料的完整性，
2.也可以這里理解:執行緒同步，即當有一個執行緒在對記憶體進行操作時，
其他執行緒都不可以對這個記憶體地址進行操作,直到該執行緒完成操作，其他執行緒才能對該記憶體地址進行操作.

同步具體方法-Synchronized

1．同步代碼塊
synchronized(物件){//得到物件的鎖,才能操作同步代碼
//需要被同步代碼;
}
2. synchronized還可以放在方法宣告中，表示整個方法-為同步方法
public synchronized void m (String name){
//需要被同步的代碼
}

使用Synchronized解決售票問題

代碼塊上加鎖

class SellTicket03 implements Runnable {
    private int ticketNum = 100;//讓多個執行緒共享 ticketNum
    private boolean loop = true;//控制run方法變數
    Object object=new Object(); 
    //同步方法（靜態的）的鎖為當前類本身
    //老韓解讀
    //1. public synchronized static void m1() {} 鎖是加在 SellTicket03.class
    //2. 如果在靜態方法中，實作一個同步代碼塊.
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
    public static  void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //老韓說明
    //1. public synchronized void sell() {} 就是一個同步方法
    //2. 這時鎖在 this物件
    //3. 也可以在代碼塊上寫 synchronize ,同步代碼塊, 互斥鎖還是在this物件
    public  void sell() { //同步方法, 在同一時刻， 只能有一個執行緒來執行sell方法

        synchronized (/*this*/ object) {
            if (ticketNum <= 0) {
                System.out.println("售票結束...");
                loop = false;
                return;
            }

            //休眠50毫秒, 模擬
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("視窗 " + Thread.currentThread().getName() + " 售出一張票"
                    + " 剩余票數=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }

    @Override
    public void run() {
        while (loop) {

            sell();//sell方法是一共同步方法
        }
    }
}

方法上加鎖

class SellTicket01 extends Thread {
    private static int nums = 1000;
    private boolean loop=true;
    public synchronized void sell() {
        if (nums <= 0) {
            System.out.println("票賣完了");
            loop=false;
            return;
        }
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("售票口" + Thread.currentThread().getName() + "賣出一張票" + "剩余票數" + (nums--));
    }

    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}

互斥鎖

基本介紹

1.Java語言中，引入了物件互斥鎖的概念，來保證共享資料操作的完整性，
2.每個物件都對應于一個可稱為“互斥鎖”的標記，這個標記用來保證在任一時刻，只能有一個執行緒訪問該物件，
3.關鍵字synchronized來與物件的互斥鎖聯系，當某個物件用synchronized修飾時，表明該物件在任一時刻只能由一個執行緒訪問
4.同步的局限性:導致程式的執行效率要降低
5.同步方法（(非靜態的)的鎖可以是this,也可以是其他物件(要求是同一個物件)
6.同步方法(靜態的)的鎖為當前類本身，

注意事項

1.同步方法如果沒有使用static修飾:默認鎖物件為this
2.如果方法使用static修飾,默認鎖物件:當前類.class(static修飾沒法用this)
3.實作的落地步驟:
·需要先分析上鎖的代碼
選擇同步代碼塊或同步方法
要求多個執行緒的鎖物件為同一個即可!

錯誤示范（鎖物件不同）

在這里插入圖片描述

執行緒死鎖

多個執行緒都占用了對方的鎖資源,但不肯相讓，導致了死鎖,在編程是一定要避免死鎖的發生.

public class DeadLock_ {
    public static void main(String[] args) {
        //模擬死鎖現象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A執行緒");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B執行緒");
        A.start();
        B.start();
    }
}


//執行緒
class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保證多執行緒，共享一個物件,這里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {//構造器
        this.flag = flag;
    }

    @Override
    public void run() {

        //下面業務邏輯的分析
        //1. 如果flag 為 T, 執行緒A 就會先得到/持有 o1 物件鎖, 然后嘗試去獲取 o2 物件鎖
        //2. 如果執行緒A 得不到 o2 物件鎖，就會Blocked
        //3. 如果flag 為 F, 執行緒B 就會先得到/持有 o2 物件鎖, 然后嘗試去獲取 o1 物件鎖
        //4. 如果執行緒B 得不到 o1 物件鎖，就會Blocked
        if (flag) {
            synchronized (o1) {//物件互斥鎖, 下面就是同步代碼
                System.out.println(Thread.currentThread().getName() + " 進入1");
                synchronized (o2) { // 這里獲得li物件的監視權
                    System.out.println(Thread.currentThread().getName() + " 進入2");
                }
                
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 進入3");
                synchronized (o1) { // 這里獲得li物件的監視權
                    System.out.println(Thread.currentThread().getName() + " 進入4");
                }
            }
        }
    }
}

釋放鎖和不釋放鎖情況

在這里插入圖片描述

本章作業

在這里插入圖片描述

package Threaduse.HomeWork;

import java.util.Locale;
import java.util.Scanner;

//(1)在main方法中啟動兩個執行緒
//(2)第1個執行緒回圈隨機列印100以內的整數
//(3)直到第2個執行緒從鍵盤讀取了“Q”命令，
public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        a.start();
        b.start();
    }
}
class A extends Thread {
    private  boolean loop=true;
    public  void setLoop(boolean b){
        loop=b;
    }
    @Override
    public void run() {
        //隨機列印100以內的整數
        while(loop){
            System.out.println((int)(Math.random()*100+1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("執行緒A結束");
    }
}
class B extends Thread {
    private A a;
    Scanner scanner = new Scanner(System.in);
    public B(A a){
        this.a=a;
    }
    @Override
    public void run() {
        //接收鍵盤輸入，當接受到"Q"后將loop=false;打斷執行緒1
        while(true){
            char s=scanner.next().charAt(0);
            if(s=='Q') {
                a.setLoop(false);
                System.out.println("執行緒B結束");
              break;
            }
        }
    }
}

在這里插入圖片描述

package Threaduse.HomeWork;

public class Homework02 {
    public static void main(String[] args) {
        user user1 = new user();
        Thread thread1= new Thread(user1);
        Thread thread2 = new Thread(user1);
        thread1.setName("用戶1");
        thread2.setName("用戶2");
        thread1.start();
        thread2.start();

    }
}
class user implements Runnable{
    private  int money=10000;
    public void put(){
            while (true){
                synchronized (this) {
                    //不斷從卡里取錢，每次取1000
                    if (money < 1000) {
                        System.out.println("卡里余額不足");
                        break;
                    }
                    money -= 1000;
                    System.out.println(Thread.currentThread().getName() + "正在取錢剩余余額" + (money));
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    }
    @Override
    public void run() {
        put();
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/321309.html

標籤：其他

上一篇：c++例外處理

下一篇：AndroidStudio SonarLint和SonarQube的使用

Java執行緒（基礎）

目錄

執行緒介紹

行程

執行緒

單、多執行緒

并發和并行

執行緒的使用

創建執行緒的兩種方法

機制說明

舉例說明（繼承Thread類重寫run（）方法實作執行緒）

為什么呼叫start（）不直接呼叫run（）方法？

舉例（實作Runnable介面實作執行緒）

繼承Thread和Runnable介面對比

售票系統（出現了超票問題，該怎么解決）

執行緒終止

執行緒的常用方法

第一組

第二組

例子

用戶執行緒和守護執行緒

如何將執行緒設定為守護執行緒

執行緒的生命周期

Synchronized（行程同步機制）

同步具體方法-Synchronized

使用Synchronized解決售票問題

代碼塊上加鎖

方法上加鎖

互斥鎖

基本介紹

注意事項

錯誤示范（鎖物件不同）

執行緒死鎖

釋放鎖和不釋放鎖情況

本章作業