學(xué)習(xí)java多線程

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

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

介紹

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

為什么需要多線程

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

線程狀態(tài)轉(zhuǎn)換

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

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

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

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

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

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

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

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

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

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

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

線程使用方式

有三種使用線程的方法:

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

實(shí)現(xiàn) Runnable 和 Callable 接口的類只能當(dāng)做一個(gè)可以在線程中運(yùn)行的任務(wù)，不是真正意義上的線程，因此最后還需要通過 Thread 來調(diào)用?？梢哉f任務(wù)是通過線程驅(qū)動(dòng)從而執(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方法開啟線程，因?yàn)檫€會(huì)在主線程中運(yùn)行，應(yīng)該使用start方法開啟線程
        //不能通過調(diào)用兩次start方法來開啟兩個(gè)子線程
        t1.start();
 
        //可以通過再創(chuàng)建一個(gè)對象來實(shí)現(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();
 
        //通過匿名子類實(shí)現(xiàn)調(diào)用：特點(diǎn)只需要調(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);
            }
        }
    }
}

實(shí)現(xiàn) Runnable 接口

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

實(shí)現(xiàn) Callable 接口

線程常見方法

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

一把鎖只能同時(shí)被一個(gè)線程獲取，沒有獲得鎖的線程只能等待；
每個(gè)實(shí)例都對應(yīng)有自己的一把鎖(this),不同實(shí)例之間互不影響；例外：鎖對象是*.class以及synchronized修飾的是static方法的時(shí)候，所有對象公用同一把鎖
synchronized修飾的方法，無論方法正常執(zhí)行完畢還是拋出異常，都會(huì)釋放鎖

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

/**
 *方式一:同步代碼塊
 * synchronized(同步監(jiān)視器){
 *          //需要被同步的代碼
 *  }
 * 說明:
 * 1.操作共享數(shù)據(jù)的代碼，即為需要被同步的代碼
 * 2.共享數(shù)據(jù):多個(gè)線程共同操作的變量
 * 3.同步監(jiān)視器，俗稱:鎖。任何一個(gè)類的對象都可以作為索
 * 4.在Java中，我們通過同步機(jī)制，來解決線程的安全問題。
 * 補(bǔ)充:在實(shí)現(xiàn)Runnable接口創(chuàng)建多線程的方式中，我們可以考慮使用this充當(dāng)同步監(jiān)視器。
 * 方式二:同步方法
 *  如果操作共享數(shù)據(jù)的代碼完整的聲明在一個(gè)方法中，我們不妨將此方法聲明同步的。
 * 5.同步的方式，解決了線程的安全問題。---好處
 * 操作同步代碼時(shí)，只能有一個(gè)線程參與，其他線程等待。相當(dāng)于是一個(gè)單線程的過程，效率低。
 */
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,因?yàn)檎{(diào)用的對象只有一個(gè)
    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() + "買票,票號(hào):" + ticket);
                    ticket--;
                }
            }
        }
    }
}

同步方法--Runnable接口方法

package com.atguigu.juc.bookPage;
 
/**
 * 使用同步方法解決實(shí)現(xiàn)Runnable接口的線程安全問題
 * 關(guān)于同步方法的總結(jié):
 * 1.同步方法仍然涉及到同步監(jiān)視器，只是不需要我們顯式的聲明。
 * 2．非靜態(tài)的同步方法，同步監(jiān)視器是: this
 * 靜態(tài)的同步方法，同步監(jiān)視器是:當(dāng)前類本身
 */
 
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()+":買票：票號(hào)為"+ticket);
            ticket--;
        }
    }
}

同步方法---繼承方法

package com.atguigu.juc.bookPage;
 
/**
 * 使用同步方法解決實(shí)現(xiàn)Runnable接口的線程安全問題
 * 關(guān)于同步方法的總結(jié):
 * 1.同步方法仍然涉及到同步監(jiān)視器，只是不需要我們顯式的聲明。
 * 2．非靜態(tài)的同步方法，同步監(jiān)視器是: this
 * 靜態(tài)的同步方法，同步監(jiān)視器是:當(dāng)前類本身
 */
 
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()+":買票：票號(hào)為"+ticket);
            ticket--;
        }
    }
}

死鎖

示例：兩個(gè)線程都拿到第一層鎖的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鎖機(jī)制

import java.util.concurrent.locks.ReentrantLock;
 
/**
 * 解決線程安全問題的方式三: Lock鎖--- JDK5.0新增
 *
 * synchronized 與Lock的異同?
 * 相同:二者都可以解決線程安全問題
 * 不同: synchronized機(jī)制在執(zhí)行完相應(yīng)的同步代碼以后，自動(dòng)的釋放同步監(jiān)視器
 *      Lock需要手動(dòng)的啟動(dòng)同步(Lock() )，同時(shí)結(jié)束同步也需要手動(dòng)的實(shí)現(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()+"買票：票號(hào)："+ticker);
 
                    ticker--;
                }else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

　　銀行有一個(gè)賬戶。有兩個(gè)儲(chǔ)戶分別向同一個(gè)賬戶存3000元，每次存1e00，存3次。每次存完打印賬戶余額。

/**
 * 銀行有一個(gè)賬戶。
 * 有兩個(gè)儲(chǔ)戶分別向同一個(gè)賬戶存3000元，每次存1e00，存3次。每次存完打印賬戶余額。
 * 分析:
 * 1.是否是多線程問題?是，兩個(gè)儲(chǔ)戶線程
 * 2.是否有共享數(shù)據(jù)?有，賬戶（或賬戶余額).
 * 3.是否有線程安全問題?有
 * 4.需要考慮如何解決線程安全問題?同步機(jī)制:有三種方式。
 */
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

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

您可能感興趣的文章:

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片