2. 程式人生 > >JAVA多執行緒————一篇文章讓你徹底征服多執行緒開發

JAVA多執行緒————一篇文章讓你徹底征服多執行緒開發

阿新 • • 發佈：2018-12-26

多執行緒的基本概念

執行緒指程序中的一個執行場景，也就是執行流程，那麼程序和執行緒有什麼區別呢？

  • 每個程序是一個應用程式，都有獨立的記憶體空間
  • 同一個程序中的執行緒共享其程序中的記憶體和資源（共享的記憶體是堆記憶體和方法區記憶體，棧記憶體不共享，每個執行緒有自己的。）

什麼是程序？

一個程序對應一個應用程式。例如：在 windows 作業系統啟動 Word 就表示啟動了一個 
程序。在 java 的開發環境下啟動 JVM，就表示啟動了一個程序。現代的計算機都是支援多 
程序的，在同一個作業系統中，可以同時啟動多個程序。

多程序有什麼作用？

單程序計算機只能做一件事情。 
玩電腦，一邊玩遊戲（遊戲程序）一邊聽音樂（音樂程序）。 
對於單核計算機來講，在同一個時間點上，遊戲程序和音樂程序是同時在執行嗎？不是。 
因為計算機的 CPU 只能在某個時間點上做一件事。由於計算機將在“遊戲程序”和“音樂 
程序”之間頻繁的切換執行，切換速度極高，人類感覺遊戲和音樂在同時進行。 
多程序的作用不是提高執行速度，而是提高 CPU 的使用率。 
程序和程序之間的記憶體是獨立的。

什麼是執行緒？

執行緒是一個程序中的執行場景。一個程序可以啟動多個執行緒。

多執行緒有什麼作用？

多執行緒不是為了提高執行速度，而是提高應用程式的使用率。 
執行緒和執行緒共享“堆記憶體和方法區記憶體”，棧記憶體是獨立的，一個執行緒一個棧。 
可以給現實世界中的人類一種錯覺：感覺多個執行緒在同時併發執行。

java 程式的執行原理？

java 命令會啟動 java 虛擬機器，啟動 JVM，等於啟動了一個應用程式，表示啟動了一個程序。該程序會自動啟動一個“主執行緒”，然後主執行緒去呼叫某個類的 main 方法。所以 main方法執行在主執行緒中。在此之前的所有程式都是單執行緒的。

執行緒生命週期

執行緒是一個程序

中的執行場景,一個程序可以啟動多個執行緒 
這裡寫圖片描述
新建：採用 new 語句建立完成 
就緒：執行 start 後 
執行：佔用 CPU 時間 
阻塞：執行了 wait 語句、執行了 sleep 語句和等待某個物件鎖，等待輸入的場合 
終止：退出 run()方法

多執行緒不是為了提高執行速度,而是提高應用程式的使用率.

執行緒和執行緒共享”堆記憶體和方法區記憶體”.棧記憶體是獨立的,一個執行緒一個棧.

可以給現實世界中的人類一種錯覺 : 感覺多執行緒在同時併發執行.

很多人都對其中的一些概念不夠明確，如同步、併發等等，讓我們先建立一個數據字典，以免產生誤會。

  • 多執行緒：指的是這個程式（一個程序）執行時產生了不止一個執行緒
  • 並行與併發：
    • 並行：多個cpu例項或者多臺機器同時執行一段處理邏輯，是真正的同時。
    • 併發：通過cpu排程演算法，讓使用者看上去同時執行，實際上從cpu操作層面不是真正的同時。併發往往在場景中有公用的資源，那麼針對這個公用的資源往往產生瓶頸，我們會用TPS或者QPS來反應這個系統的處理能力。

    執行緒安全：經常用來描繪一段程式碼。指在併發的情況之下，該程式碼經過多執行緒使用，執行緒的排程順序不影響任何結果。這個時候使用多執行緒，我們只需要關注系統的記憶體，cpu是不是夠用即可。反過來，執行緒不安全就意味著執行緒的排程順序會影響最終結果，如不加事務的轉賬程式碼：

 void transferMoney(User from, User to, float amount){

   to.setMoney(to.getBalance() + amount);

   from.setMoney(from.getBalance() - amount);
 }

同步：Java中的同步指的是通過人為的控制和排程，保證共享資源的多執行緒訪問成為執行緒安全，來保證結果的準確。如上面的程式碼簡單加入@synchronized關鍵字。在保證結果準確的同時，提高效能，才是優秀的程式。執行緒安全的優先順序高於效能。

Java命令會啟動Java虛擬機器,啟動JVM,等於啟動了一個應用程式,表示啟動了一個程序,該程序會自動啟動一個”主執行緒”,

然後主執行緒去呼叫某個類的main()方法,所以main()方法執行在主執行緒中.

http://upload-images.jianshu.io/upload_images/1689841-383f7101e6588094.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240&_=5479442

執行緒的排程與控制

執行緒的排程模型分為: 分時排程模型和搶佔式排程模型,Java使用搶佔式排程模型 
通常我們的計算機只有一個 CPU，CPU 在某一個時刻只能執行一條指令，執行緒只有得到 CPU時間片，也就是使用權，才可以執行指令。在單 CPU 的機器上執行緒不是並行執行的，只有在多個 CPU 上執行緒才可以並行執行。Java 虛擬機器要負責執行緒的排程，取得 CPU 的使用權，目前有兩種排程模型：分時排程模型和搶佔式排程模型，Java 使用搶佔式排程模型。分時排程模型：所有執行緒輪流使用 CPU 的使用權，平均分配每個執行緒佔用 CPU 的時間片搶佔式排程模型：優先讓優先順序高的執行緒使用 CPU，如果執行緒的優先順序相同，那麼會隨機選擇一個，優先順序高的執行緒獲取的 CPU 時間片相對多一些。

  • 分時排程模型: 所有執行緒輪流使用CPU的使用權,平均分配每個執行緒佔用CPU的時間片
  • 搶佔式排程模型: 優先讓優先順序高的執行緒使用CPU,如果執行緒的優先順序相同,那麼會隨機選擇一個,優先順序高的執行緒獲取的CPU時間片相對多一些.
public class ThreadTest {

    public static void main(String[] args) {
        ThreadTest1();
        ThreadTest2();
        ThreadTest3();
        ThreadTest4();
        ThreadTest5();
    }

    /**
     * 三個方法: 獲取當前執行緒物件:Thread.currentThread(); 給執行緒起名: t1.setName("t1"); 獲取執行緒的名字: t.getName();
     */
    private static void ThreadTest1() {
        Thread t = Thread.currentThread();// t儲存的記憶體地址指向的執行緒為"主執行緒"
        System.out.println(t.getId());
        Thread t1 = new Thread(new Processor1());
        // 給執行緒起名
        t1.setName("t1");
        t1.start();
        Thread t2 = new Thread(new Processor1());
        t2.setName("t2");
        t2.start();
    }

    /**
     * 執行緒優先順序高的獲取的CPU時間片相對多一些 優先順序: 1-10 最低: 1 最高: 10 預設: 5
     */
    private static void ThreadTest2() {
        Thread t1 = new Processor2();
        Thread t2 = new Processor2();
        t1.setName("t1");
        t2.setName("t2");

        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        t1.setPriority(1);
        t2.setPriority(10);

        t1.start();
        t2.start();
    }

    /**
     * 1.Thread.sleep(毫秒); 2.sleep方法是一個靜態方法 3.該方法的作用: 阻塞當前執行緒,騰出CPU,讓給其它執行緒
     */
    private static void ThreadTest3() {
        Thread t = new Thread(new Processor3());
        t.start();
        for (int i = 0; i < 11; i++) {
            System.out.println(Thread.currentThread().getName() + "========>" + i);
            try {
                t.sleep(5000);// 等同於Thread.sleep(5000);阻塞的還是當前執行緒,和t執行緒無關.
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 某執行緒正在休眠,如何打斷它的休眠 以下方式依靠的是異常處理機制
     */
    private static void ThreadTest4() {
        try {
            Thread t = new Thread(new Processor4());
            t.start();
            Thread.sleep(5000);// 睡5s
            t.interrupt();// 打斷Thread的睡眠
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 如何正確的更好的終止一個正在執行的執行緒 需求:執行緒啟動5s之後終止.
     */
    private static void ThreadTest5() {
        Processor5 p = new Processor5();
        Thread t = new Thread(p);
        t.start();
        // 5s之後終止
        try {
            Thread.sleep(5000);
            p.isRun = false;
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class Processor1 implements Runnable {

    @Override
    public void run() {
        Thread t = Thread.currentThread();// t儲存的記憶體地址指向的執行緒為"t1執行緒物件"
        System.out.println(t.getName());
        System.out.println(t.getId());

    }
}

class Processor2 extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + "----------->" + i);
        }

    }
}

class Processor3 implements Runnable {

    /**
     * Thread中的run方法不能丟擲異常,所以重寫runn方法之後,在run方法的宣告位置上不能使用throws 所以run方法中的異常只能try...catch...
     */
    @Override
    public void run() {
        for (int i = 0; i < 11; i++) {
            System.out.println(Thread.currentThread().getName() + "========>" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class Processor4 implements Runnable {

    @Override
    public void run() {
        try {
            Thread.sleep(1000000000);
            System.out.println("能否執行這裡");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 11; i++) {
            System.out.println(Thread.currentThread().getName() + "========>" + i);
        }
    }
}

class Processor5 implements Runnable {

    boolean isRun = true;

    @Override
    public void run() {
        for (int i = 0; i < 11; i++) {
            if (isRun) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "========>" + i);
            }
        }
    }
}

本文所有程式碼已經完整附上,如果想檢視執行結果,可以把程式碼直接複製到開發工具執行檢視

執行緒優先順序

線 程 優 先 級 主 要 分 三 種 ： MAX_PRIORITY( 最 高 級 );MIN_PRIORITY （ 最 低 級 ）NORM_PRIORITY(標準)預設

//設定執行緒的優先順序，執行緒啟動後不能再次設定優先順序
//必須在啟動前設定優先順序
//設定最高優先順序
t1.setPriority(Thread.MAX_PRIORITY);

sleep

sleep 設定休眠的時間,單位毫秒，當一個執行緒遇到 sleep 的時候，就會睡眠，進入到阻塞狀態,放棄 CPU，騰出 cpu 時間片，給其他執行緒用，所以在開發中通常我們會這樣做，使其他的執行緒能夠取得 CPU 時間片，當睡眠時間到達了，執行緒會進入可執行狀態，得到 CPU 時間片繼續執行，如果執行緒在睡眠狀態被中斷了，將會丟擲 IterruptedException

    public class ThreadTest05 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();
            Thread t2 = new Thread(r1, "t2");
            t2.start();
        }
    }
    class Processor implements Runnable {
        public void run() {
            for (int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName() + "," + i);
        if (i % 10 == 0) {
            try {
        //睡眠 100 毫秒，主要是放棄 CPU 的使用，將 CPU 時間片交給其他執行緒使用
        Thread.sleep(100);
            }catch(InterruptedException e) {
            e.printStackTrace();
                }
            }
        }
    }
}

停止一個執行緒

  • 如果我們的執行緒正在睡眠，可以採用 interrupt 進行中斷
  • 通常定義一個標記，來判斷標記的狀態停止執行緒的執行

yield

它與 sleep()類似，只是不能由使用者指定暫停多長時間，並且 yield()方法只能讓同優先順序的執行緒有執行的機會,採用 yieid 可以將 CPU 的使用權讓給同一個優先順序的執行緒

join

當前執行緒可以呼叫另一個執行緒的 join 方法，呼叫後當前執行緒會被阻塞不再執行，直到被呼叫的執行緒執行完畢，當前執行緒才會執行

synchronized

執行緒同步，指某一個時刻，指允許一個執行緒來訪問共享資源，執行緒同步其實是對物件加鎖，如果物件中的方法都是同步方法，那麼某一時刻只能執行一個方法，採用執行緒同步解決以上的問題，我們只要保證執行緒一操作 s 時，執行緒 2 不允許操作即可，只有執行緒一使用完成 s 後，再讓執行緒二來使用 s 變數

  • 非同步程式設計模型 : t1執行緒執行t1的,t2執行緒執行t2的,兩個執行緒之間誰也不等誰.
  • 同步程式設計模型 : t1執行緒和t2執行緒執行,t2執行緒必須等t1執行緒執行結束之後,t2執行緒才能執行,這是同步程式設計模型.
  • ​
  • 什麼時候要用同步呢?為什麼要引入執行緒同步呢?
  • 1.為了資料的安全,儘管應用程式的使用率降低,但是為了保證資料是安全的,必須加入執行緒同步機制.
  • 執行緒同步機制使程式變成了(等同)單執行緒.
  • 2.什麼條件下要使用執行緒同步?
  • 第一: 必須是多執行緒環境
  • 第二: 多執行緒環境共享同一個資料.
  • 第三: 共享的資料涉及到修改操作.
//synchronized 是對物件加鎖
//採用 synchronized 同步最好只同步有執行緒安全的程式碼
//可以優先考慮使用 synchronized 同步塊
//因為同步的程式碼越多，執行的時間就會越長，其他執行緒等待的時間就會越長
//影響效率
    public synchronized void run() {
//使用同步塊
    synchronized (this) {
        for (int i=0; i<10; i++) {
            s+=i;
        }
    System.out.println(Thread.currentThread().getName() + ", s=" + s);
    s = 0;
    }
public class SynchronizedTest {
    public static void main(String[] args) {
        SynchronizeTest1();
    }

    private static void SynchronizeTest1() {
        Account account=new Account("Actno-001",5000.0);
        Thread t1=new Thread(new Processor(account));
        Thread t2=new Thread(new Processor(account));
        t1.start();
        t2.start();
    }

}
/**
 * 取款執行緒
 */
class Processor implements Runnable{
    Account act;
    Processor(Account act){
        this.act=act;
    }
    @Override
    public void run() {
        act.withdraw(1000.0);
        System.out.println("取款1000.0成功,餘額: "+act.getBalance());
    }

}
class Account {

    private String actno;
    private double balance;

    public Account() {
        super();
    }

    public Account(String actno, double balance) {
        super();
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    /**
     * 對外提供一個取款的方法 對當前賬戶進行取款操作
     */
    public void withdraw(double money) {
        //把需要同步的程式碼,放到同步語句塊中.
        //遇到synchronized就找鎖,找到就執行,找不到就等
        /**
         * 原理: t1執行緒和t2執行緒
         * t1執行緒執行到此處,遇到了synchronized關鍵字,就會去找this的物件鎖,
         * 如果找到this物件鎖,則進入同步語句塊中執行程式,當同步語句塊中的程式碼執行結束之後,
         * t1執行緒歸還this的物件鎖.
         * 
         * 在t1執行緒執行同步語句塊的過程中,如果t2執行緒也過來執行以下程式碼,也遇到synchronized關鍵字,
         * 所以也去找this物件鎖,但是該物件鎖被t1執行緒持有,只能在這等待this物件的歸還.
         * 
         * synchronized關鍵字新增到成員方法上,執行緒拿走的也是this的物件鎖.
         * 
         */
        synchronized (this) {
            double after = balance - money;
            try {
                //延遲
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //更新
            this.setBalance(after);
        }
    }
}
public class SynchronizedTest2 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1=new MyClass();
        MyClass mc2=new MyClass();
        Thread t1=new Thread(new Runnable1(mc1));
        Thread t2=new Thread(new Runnable1(mc2));
        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        //延遲,保證t1先執行
        Thread.sleep(1000);
        t2.start();
    }
}
class Runnable1 implements Runnable{
    MyClass mc;
    Runnable1(MyClass mc){
        this.mc=mc;
    }
    @Override
    public void run() {
        if("t1".equals(Thread.currentThread().getName())){
            MyClass.m1();//因為是靜態方法,用的還是類鎖,和物件鎖無關
        }
        if("t2".equals(Thread.currentThread().getName())){
            MyClass.m2();
        }
    }
}
class MyClass{
    //synchronized新增到靜態方法上,執行緒執行此方法的時候會找類鎖,類鎖只有一把
    public synchronized static void m1(){
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("m1()............");
    }
    /**
     *  m2()不會等m1結束,因為該方法沒有被synchronized修飾
     */
//    public static void m2(){
//        System.out.println("m2()........");
//    }
    /**
     * m2方法等m1結束之後才能執行,該方法有synchronized
     * 執行緒執行該方法需要"類鎖",而類鎖只有一個.
     */
    public synchronized static void m2(){
        System.out.println("m2()........");
    }
}

死鎖

public class DeadLock {

    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        Thread t1 = new Thread(new T1(o1, o2));
        Thread t2 = new Thread(new T2(o1, o2));
        t1.start();
        t2.start();
    }
}

class T1 implements Runnable {

    Object o1;
    Object o2;

    T1(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2) {

            }
        }
    }
}

class T2 implements Runnable {

    Object o1;
    Object o2;

    T2(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1) {

            }
        }
    }
}

守護執行緒

從執行緒分類上可以分為：使用者執行緒（以上講的都是使用者執行緒），另一個是守護執行緒。守護執行緒是這樣的，所有的使用者執行緒結束生命週期，守護執行緒才會結束生命週期，只要有一個使用者執行緒存在，那麼守護執行緒就不會結束，例如 java 中著名的垃圾回收器就是一個守護執行緒，只有應用程式中所有的執行緒結束，它才會結束。

  • 其它所有的使用者執行緒結束,則守護執行緒退出!
  • 守護執行緒一般都是無限執行的.
public class DaemonThread {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable2());
        t1.setName("t1");
        // 將t1這個使用者執行緒修改成守護執行緒.線上程沒有啟動時可以修改以下引數
        t1.setDaemon(true);
        t1.start();
        // 主執行緒
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "----->" + i);
            Thread.sleep(1000);
        }
    }
}

class Runnable2 implements Runnable {

    @Override
    public void run() {
        int i = 0;
        while (true) {
            i++;
            System.out.println(Thread.currentThread().getName() + "-------->" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

設定為守護執行緒後，當主執行緒結束後，守護執行緒並沒有把所有的資料輸出完就結束了，也即是說守護執行緒是為使用者執行緒服務的，當用戶執行緒全部結束，守護執行緒會自動結束

Timer.schedule()

/**
 * 關於定時器的應用 作用: 每隔一段固定的時間執行一段程式碼
 */
public class TimerTest {

    public static void main(String[] args) throws ParseException {
        // 1.建立定時器
        Timer t = new Timer();
        // 2.指定定時任務
        t.schedule(new LogTimerTask(), new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").parse("2017-06-29 14:24:00 000"), 10 * 1000);
    }
}

// 指定任務
class LogTimerTask extends TimerTask {

    @Override
    public void run() {
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()));
    }
}

相關推薦

JAVA多執行緒————一篇文章讓你徹底征服多執行緒開發(一)

多執行緒的基本概念 執行緒指程序中的一個執行場景，也就是執行流程，那麼程序和執行緒有什麼區別呢？ 每個程序是一個應用程式，都有獨立的記憶體空間 同一個程序中的執行緒共享其程序中的記憶體和資源（共享的記憶體是堆記憶體和方法區記憶體，棧記憶體不共享，

JAVA多執行緒————一篇文章讓你徹底征服多執行緒開發

多執行緒的基本概念執行緒指程序中的一個執行場景，也就是執行流程，那麼程序和執行緒有什麼區別呢？每個程序是一個應用程式，都有獨立的記憶體空間同一個程序中的執行緒共享其程序中的記憶體和資源（共享的記憶體是堆記憶體和方法區記憶體，棧記憶體不共享，每個執行緒有自己的。）什麼是程序？一

一篇文章讓你徹底征服多執行緒開發

多執行緒的基本概念 執行緒指程序中的一個執行場景，也就是執行流程，那麼程序和執行緒有什麼區別呢？ 每個程序是一個應用程式，都有獨立的記憶體空間 同一個程序中的執行緒共享其程序中的記憶體和資源（共享的記憶體是堆記憶體和方法區記憶體，棧記憶體不共享，

#一篇文章讓你瞭解四種執行緒池，學習Java不在困惑

在Java開發中，有時遇到多執行緒的開發時，直接使用Thread操作，對程式的效能和維護上都是一個問題，使用Java提供的執行緒池來操作可以很好的解決問題，於是找了下API看到Java提供四種執行緒池使用，Java通過Executors提供四種執行緒池，分別為： 1、newCachedThrea

#Java乾貨分享：一篇文章讓你深入瞭解Java中的包和介面

很多新手程式設計師對於Java中兩個具創新性的特徵————包與介面不是非常清楚，所以我特意發了這篇文章來闡述什麼是包，什麼是介面。 包（package）是多個類的容器，它們用於保持類的名稱空間相互隔離。 如果有想學習java的程式設計師，可來我們的java學習扣qun：79979，2590免

一篇文章讓你徹底瞭解Java內部類

內容整理自《Thinking in Java》(第四版) 第10章 PDF下載地址 什麼是內部類? 將一個類的定義，放在另一個類的定義內部，那這個類，就是內部類 為什麼需要內部類？ 一般來說，內部類繼承自某個類或實現某個介面，內部類的程式碼操作建立其的

一篇文章讓你徹底理解java中抽象類和介面

目錄 1、我所理解的抽象類 2、我所理解的介面 3、抽象類和介面本質區別 相信大家都有這種感覺：抽象類與介面這兩者有太多相似的地方，又有太多不同的地方。往往這二者可以讓初學者摸不著頭腦，無論是在

一篇文章讓你徹底明白區塊鏈有哪些應用場景

    Ripple: 區塊鏈跨境支付與外匯結算系統 　　Ripple為銀行類金融機構提供跨境支付服務，希望取代環球同業銀行金融電訊協會（SWIFT）的跨境轉賬平臺，打造全球統一的網路金融傳輸協議；利用Ripple的跨賬本協議（Interledger Protocol），所有參與者都能看到同一個賬本，銀

一篇文章讓你瞭解動態陣列的資料結構的實現過程（Java 實現）

[TOC] ## 陣列基礎簡單回顧 1. 陣列是一種資料結構，用來儲存**同一型別值**的集合。 2. 陣列就是**儲存資料長度固定的容器**，保證**多個數據的資料型別要一致**。 3. 陣列是一種**引用資料型別**。 4. 簡單來說，陣列就是把需要儲存的資料排成一排進行存放。 5. 陣列的索引從 *

一篇文章讓你讀懂什麽是餐飲小程序

用戶 事情 right 連接 不用 距離 掃描二維碼 left 企業 小程序火了，餐飲+小程序也火了！ 作為連接線下消費場景和線上營銷的新工具，小程序出現後，迅速贏得了餐飲商家的青睞。與其說，小程序對餐飲行業“情有獨鐘”；不如說，兩者是“情投意合”。 20天

一篇文章讓你明白python的裝飾器

pri 9.png 不同 概念 ota 一起 數字 上下文 讀取 在看閉包問題之前先來看看關於python中作用域的問題 變量作用域 對於上述代碼中出現錯誤，肯定沒什麽疑問了，畢竟b並沒有定義和賦值，當我們把代碼更改如下後： 再看一個例子： 首先這個錯誤已經非常明顯

一篇文章讓你了解DNS

遞歸查詢 叠代查詢 反向解析 DNS報文格式 目錄什麽是DNSDNS的特點DNS的工作原理反向解析DNS的報文格式一、什麽是DNS DNS--Domain Name System，域名系統。 互聯網中計算機之間進行通訊，數據怎麽走，走向哪裏，這些都需要根據IP地址來

一篇文章讓你知道什麽是數據挖掘

大數據 數據挖掘 數據庫 大數據如果想要產生價值，對它的處理過程無疑是非常重要的，其中大數據分析和大數據挖掘就是最重要的兩部分。在前幾期的科普中，小編已經為大家介紹了大數據分析的相關情況，本期小編就為大家講解大數據挖掘技術，讓大家輕輕松松弄懂什麽是大數據挖掘技術。什麽是大數據挖掘？數據挖掘(Dat

一篇文章讓你豁然開朗，成為架構師你必須了解的一些疑問

有一點 同事 繼續 模式 常見 瓶頸 功能實現 很多 獨立 前言：我先介紹一下我的新同事，公司好多同事都這麽叫他James，有10年開發經驗的架構師，之前在人人網待過，之後我們也聊了很多。 在聊天過程中，我們也聊到了他為什麽離開人人網，也聊到了他在成為架構師的道路上的辛酸歷

一篇文章讓你快速入門 學懂Shell腳本

運行 turn origin 判斷語句 load for循環 網絡操作 場景 個數字 Shell腳本,就是利用Shell的命令解釋的功能，對一個純文本的文件進行解析，然後執行這些功能，也可以說Shell腳本就是一系列命令的集合。 Shell可以直接使用在win/Uni

止損不見得能控制住回撤，一篇文章讓你認清自己的止損！

結果 股票 部分 接下來 ESS 我希望 錯誤 占比 被套 首發：寬客在線 NO：01文字並不具備精確傳遞信息的能力。除了程序員和律師等少數群體，很少人能保證自己說的東西能在一句話中被清晰傳遞的。所以，帶著思考閱讀從而幫助完善你的知識體系，改變你的行為，這才是您耗費時間，閱

一篇文章讓你瞭解GC垃圾回收器

簡單瞭解GC垃圾回收器 瞭解GC之前我們首先要了解GC是要做什麼的？顧名思義回收垃圾，什麼是垃圾呢？ GC回收的垃圾主要指的是回收堆記憶體中的垃圾物件。 從根物件出發，所有被引用的物件，都是存活物件 其他物件，都是垃圾物件。  根物件： 　　 棧中的引用變數，所引用的物

一篇文章讓你了解GC垃圾回收器

存滿 需要 進行 並行 mil 之間 consola 微軟雅黑 並行執行 簡單了解GC垃圾回收器 了解GC之前我們首先要了解GC是要做什麽的？顧名思義回收垃圾，什麽是垃圾呢？ GC回收的垃圾主要指的是回收堆內存中的垃圾對象。 從根對象出發，所有被引用的對象，都是存活對象 其

一篇文章讓你真正讀懂HashMap

前言------ 在使用HashMap的過程中,是否對key值不能重複有過疑問? 是否對改原因百思不得其解? 是否只會使用常用方法?  是否很想理解hash演算法為基礎的HashMap?  如果有, 那麼恭喜你哈, 找對文章了! 歡迎轉載,轉載請註明來源  

一篇文章讓你瞭解大資料採集技術

大資料開啟了一個大規模生產、分享和應用資料的時代，它給技術和商業帶來了巨大的變化。麥肯錫研究表明，在醫療、零售和製造業領域，大資料每年可以提高勞動生產率0.5-1個百分點。大資料在核心領域的滲透速度有目共睹，然而調查顯示，未被使用的資訊比例高達99.4%，很大程度都是由於高價值的資訊無法獲取採集。因