學習java多線程

更新時間：2021年08月25日 10:15:45 作者：CooperMiNi

本文運用了大量的代碼講解了java多線程，它可以提高程序并行執(zhí)行的速度，更快的響應程序。感興趣的小伙伴一起來看看吧

介紹

程序(program)是為完成特定任務、用某種語言編寫的一組指令的集合。即指一段靜態(tài)的代碼，靜態(tài)對象。
進程(process)是程序的一次執(zhí)行過程，或是正在運行的一個程序。是一個動態(tài)的過程:有它自身的產(chǎn)生、存在和消亡的過程?！芷?br /> 　　>如:運行中的QQ，運行中的MP3播放器
　　>程序是靜態(tài)的，進程是動態(tài)的
　　>進程作為資源分配的單位，系統(tǒng)在運行時會為每個進程分配不同的內(nèi)存區(qū)域
線程(thread)，進程可進一步細化為線程，是一個程序內(nèi)部的一條執(zhí)行路徑。若一個進程同一時間并行執(zhí)行多個線程，就是支持多線程的線程作為調(diào)度和執(zhí)行的單位，每個線程擁有獨立的運行棧和程序計數(shù)器(pc)，線程切換的開銷小；
一個進程中的多個線程共享相同的內(nèi)存單元/內(nèi)存地址空間→它們從同一堆中分配對象，可以訪問相同的變量和對象。這就使得線程間通信更簡便、高效。但多個線程操作共享的系統(tǒng)資源可能就會帶來安全的隱患。

為什么需要多線程

眾所周知，CPU、內(nèi)存、I/O 設備的速度是有極大差異的，為了合理利用 CPU 的高性能，平衡這三者的速度差異，計算機體系結構、操作系統(tǒng)、編譯程序都做出了貢獻。

線程狀態(tài)轉換

新建(New)
創(chuàng)建后尚未啟動。

就緒(Runnable)
可能正在運行，也可能正在等待 CPU 時間片。

包含了操作系統(tǒng)線程狀態(tài)中的 Running 和 Ready。

阻塞(Blocking)
等待獲取一個排它鎖，如果其線程釋放了鎖就會結束此狀態(tài)。

無限期等待(Waiting)
等待其它線程顯式地喚醒，否則不會被分配 CPU 時間片。

限期等待(Timed Waiting)
無需等待其它線程顯式地喚醒，在一定時間之后會被系統(tǒng)自動喚醒。

調(diào)用 Thread.sleep() 方法使線程進入限期等待狀態(tài)時，常常用“使一個線程睡眠”進行描述。

調(diào)用 Object.wait() 方法使線程進入限期等待或者無限期等待時，常常用“掛起一個線程”進行描述。

睡眠和掛起是用來描述行為，而阻塞和等待用來描述狀態(tài)。

阻塞和等待的區(qū)別在于，阻塞是被動的，它是在等待獲取一個排它鎖。而等待是主動的，通過調(diào)用 Thread.sleep() 和 Object.wait() 等方法進入。

死亡(Terminated)
可以是線程結束任務之后自己結束，或者產(chǎn)生了異常而結束。

線程使用方式

有三種使用線程的方法:

實現(xiàn) Runnable 接口；
實現(xiàn) Callable 接口；
繼承 Thread 類。

實現(xiàn) Runnable 和 Callable 接口的類只能當做一個可以在線程中運行的任務，不是真正意義上的線程，因此最后還需要通過 Thread 來調(diào)用?？梢哉f任務是通過線程驅動從而執(zhí)行的。

繼承 Thread 類

public class ThreadTest {
    /**
     * 多線程的創(chuàng)建，
     * 方式一：
     * 1.繼承與Thread類
     * 2.重寫Thread類的run方法->將此線程執(zhí)行的操作聲明在run中
     * 3.創(chuàng)建Thread類的子類
     * 4.通過此對象調(diào)用start
     */
    public static void main(String[] args) {
//        創(chuàng)建Thread類的子類的對象
        MyThread t1 = new MyThread();
        //不能通過run方法開啟線程，因為還會在主線程中運行，應該使用start方法開啟線程
        //不能通過調(diào)用兩次start方法來開啟兩個子線程
        t1.start();
 
        //可以通過再創(chuàng)建一個對象來實現(xiàn)
 
        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);
           }
       }
    }
}

    /**
     * 方式二：
     * 匿名子類創(chuàng)建，針對只調(diào)用一次的線程
     */
    public static void main(String[] args) {
 
        MyThread1 myThread1 = new MyThread1();
        myThread1.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
 
        //通過匿名子類實現(xiàn)調(diào)用：特點只需要調(diào)用一次的子線程
        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);
            }
        }
    }
}

實現(xiàn) Runnable 接口

package com.atguigu.juc.runnable;
 
/**
 * 創(chuàng)建多線程方式Runnable
 * 1.創(chuàng)建一個實現(xiàn)Runnable接口的類
 *
 * 2.實現(xiàn)類去實現(xiàn)Runnable中的抽象方法: run( )
 *
 * 3.創(chuàng)建實現(xiàn)類的對象
 *
 * 4、將此對象作為參數(shù)傳遞到Thread類的構造器中，創(chuàng)建Thread類的對象
 *
 * 5，通過Thread類的對象調(diào)用start()
 */
 
public class TestThread {
    public static void main(String[] args) {
        //3.創(chuàng)建實現(xiàn)類的對象
        MyThread myThread = new MyThread();
        //4、將此對象作為參數(shù)傳遞到Thread類的構造器中，創(chuàng)建Thread類的對象
        Thread t1 = new Thread(myThread);
        //5，通過Thread類的對象調(diào)用start()
        t1.start();
    }
}
//1.創(chuàng)建一個實現(xiàn)Runnable接口的類
class MyThread implements Runnable{
//2.實現(xiàn)類去實現(xiàn)Runnable中的抽象方法: run( )
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}

實現(xiàn) Callable 接口

線程常見方法

package com.atguigu.juc.tset01;
 
/**
 * 1.yield():釋放當前cpu的執(zhí)行權
 *
 * 2.start():啟動當前線程;調(diào)用當前線程的run()
 *
 * 3.run():通常需要重寫Thread類中的此方法，將創(chuàng)建的線程要執(zhí)行的操作聲明在此方法中
 *
 * 4.getName()∶獲取當前線程的名字
 *
 * 5.setName():設置當前線程的名字
 *
 * 6.currentThread():靜態(tài)方法，返回執(zhí)行當前代碼的線程
 *
 * 7.join():在線程a中調(diào)用線程b的join(),此時線程a就進入阻塞狀態(tài)，直到線程b完全執(zhí)行完以后，線程a才結束阻塞狀態(tài)。
 *
 * 8.sleep():讓當前線程"睡眠”指定的毫秒。在指定的毫秒時間內(nèi)，當前線程是阻塞狀態(tài)。
 *
 */
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修飾的方法，無論方法正常執(zhí)行完畢還是拋出異常，都會釋放鎖

同步代碼---Runnable接口方式

/**
 *方式一:同步代碼塊
 * synchronized(同步監(jiān)視器){
 *          //需要被同步的代碼
 *  }
 * 說明:
 * 1.操作共享數(shù)據(jù)的代碼，即為需要被同步的代碼
 * 2.共享數(shù)據(jù):多個線程共同操作的變量
 * 3.同步監(jiān)視器，俗稱:鎖。任何一個類的對象都可以作為索
 * 4.在Java中，我們通過同步機制，來解決線程的安全問題。
 * 補充:在實現(xiàn)Runnable接口創(chuàng)建多線程的方式中，我們可以考慮使用this充當同步監(jiān)視器。
 * 方式二:同步方法
 *  如果操作共享數(shù)據(jù)的代碼完整的聲明在一個方法中，我們不妨將此方法聲明同步的。
 * 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,因為調(diào)用的對象只有一個
    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;
 
/**
 * 使用同步方法解決實現(xiàn)Runnable接口的線程安全問題
 * 關于同步方法的總結:
 * 1.同步方法仍然涉及到同步監(jiān)視器，只是不需要我們顯式的聲明。
 * 2．非靜態(tài)的同步方法，同步監(jiān)視器是: this
 * 靜態(tài)的同步方法，同步監(jiān)視器是:當前類本身
 */
 
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;
 
/**
 * 使用同步方法解決實現(xiàn)Runnable接口的線程安全問題
 * 關于同步方法的總結:
 * 1.同步方法仍然涉及到同步監(jiān)視器，只是不需要我們顯式的聲明。
 * 2．非靜態(tài)的同步方法，同步監(jiān)視器是: this
 * 靜態(tài)的同步方法，同步監(jiān)視器是:當前類本身
 */
 
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在對方手中，而方法沒有執(zhí)行完，都不可能釋放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機制在執(zhí)行完相應的同步代碼以后，自動的釋放同步監(jiān)視器
 *      Lock需要手動的啟動同步(Lock() )，同時結束同步也需要手動的實現(xiàn)(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.是否有共享數(shù)據(jù)?有，賬戶（或賬戶余額).
 * 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

以上就是學習java多線程的詳細內(nèi)容，更多關于java多線程的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

java實現(xiàn)數(shù)據(jù)庫主鍵生成示例
這篇文章主要介紹了java實現(xiàn)數(shù)據(jù)庫主鍵生成示例,需要的朋友可以參考下
2014-03-03
以Spring Boot的方式顯示圖片或下載文件到瀏覽器的示例代碼
這篇文章主要介紹了以Spring Boot的方式顯示圖片或下載文件到瀏覽器的示例代碼,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
2021-01-01
java循環(huán)刪除List元素報錯的原因分析與解決
大家在工作中應該都會遇到從List集合中刪除某一個或多個元素的業(yè)務場景,相信大家都會避開在循環(huán)里面刪除元素,使用其他方式處理,這是為什么呢,下面小編就來和大家詳細聊聊
2023-11-11
java如何發(fā)送get請求獲取數(shù)據(jù)(附代碼)
這篇文章主要給大家介紹了關于java如何發(fā)送get請求獲取數(shù)據(jù)的相關資料,Java中的GET請求方法是HTTP協(xié)議中的一種請求方式,用于向服務器請求獲取資源,需要的朋友可以參考下
2023-10-10
JPA之EntityManager踩坑及解決:更改PersistenceContext
這篇文章主要介紹了JPA之EntityManager踩坑及解決:更改PersistenceContext方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2022-02-02
IDEA修改idea64.exe.vmoptions文件以及解決coding卡頓問題
IDEA修改idea64.exe.vmoptions文件以及解決coding卡頓問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2023-04-04
Spring的自動裝配常用注解詳解
這篇文章主要介紹了Spring的自動裝配常用注解詳解,自動裝配就是指 Spring 容器在不使用 <constructor-arg> 和<property> 標簽的情況下，可以自動裝配相互協(xié)作的 Bean 之間的關聯(lián)關系，將一個 Bean 注入其他 Bean 的 Property 中,需要的朋友可以參考下
2023-08-08
Java 自定義Spring框架與Spring IoC相關接口分析
Spring框架是由于軟件開發(fā)的復雜性而創(chuàng)建的。Spring使用的是基本的JavaBean來完成以前只可能由EJB完成的事情。然而，Spring的用途不僅僅限于服務器端的開發(fā)
2021-10-10
深入了解SparkSQL中數(shù)據(jù)的加載與保存
這篇文章主要為大家詳細介紹了SparkSQL中數(shù)據(jù)的加載與保存的相關知識,文中的示例代碼講解詳細,具有一定的學習價值,感興趣的小伙伴可以了解下
2023-11-11
ThreadLocal的set方法原理示例解析
這篇文章主要為大家介紹了ThreadLocal的set方法原理示例解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
2023-02-02