【Java】幾道常見的秋招面試題

Rocko 發(fā)布于2019-08-16 13:29 / 502人閱讀

摘要：總結的時間復雜度是，是空間是使用輔助棧來存儲最小值。項目就是為了解決配置繁瑣的問題，最大化的實現(xiàn)約定大于配置。

前言

只有光頭才能變強

Redis目前還在看，今天來分享一下我在秋招看過(遇到)的一些面試題(相對比較常見的)

0、final關鍵字

簡要說一下final關鍵字，final可以用來修飾什么？

這題我是在真實的面試中遇到的，當時答得不太好，現(xiàn)在來整理一下吧。

final可以修飾類、方法、成員變量

當final修飾類的時候，說明該類不能被繼承

當final修飾方法的時候，說明該方法不能被重寫

在早期，可能使用final修飾的方法，編譯器針對這些方法的所有調用都轉成內嵌調用，這樣提高效率(但到現(xiàn)在一般我們不會去管這事了，編譯器和JVM都越來越聰明了)

當final修飾成員變量時，有兩種情況：

如果修飾的是基本類型，說明這個變量的所代表數(shù)值永不能變(不能重新賦值)！

如果修飾的是引用類型，該變量所的引用不能變，但引用所代表的對象內容是可變的！

值得一說的是：并不是被final修飾的成員變量就一定是編譯期常量了。比如說我們可以寫出這樣的代碼：private final int java3y = new Randon().nextInt(20);

你有沒有這樣的編程經驗，在編譯器寫代碼時，某個場景下一定要將變量聲明為final，否則會出現(xiàn)編譯不通過的情況。為什么要這樣設計？

在編寫匿名內部類的時候就可能會出現(xiàn)這種情況，匿名內部類可能會使用到的變量：

外部類實例變量

方法或作用域內的局部變量

方法的參數(shù)

class Outer {


    // string:外部類的實例變量
    String string = "";


    //ch:方法的參數(shù)
    void outerTest(final char ch) {

        // integer:方法內局部變量
        final Integer integer = 1;
        new Inner() {
            void innerTest() {
                System.out.println(string);
                System.out.println(ch);
                System.out.println(integer);
            }
        };

    }
    public static void main(String[] args) {
        new Outer().outerTest(" ");
    }
    class Inner {
    }
}

其中我們可以看到：方法或作用域內的局部變量和方法參數(shù)都要顯示使用final關鍵字來修飾(在jdk1.7下)！

如果切換到jdk1.8編譯環(huán)境下，可以通過編譯的~

下面我們首先來說一下顯示聲明為final的原因：為了保持內部外部數(shù)據(jù)一致性

Java只是實現(xiàn)了capture-by-value形式的閉包，也就是匿名函數(shù)內部會重新拷貝一份自由變量，然后函數(shù)外部和函數(shù)內部就有兩份數(shù)據(jù)。

要想實現(xiàn)內部外部數(shù)據(jù)一致性目的，只能要求兩處變量不變。JDK8之前要求使用final修飾，JDK8聰明些了，可以使用effectively final的方式

為什么僅僅針對方法中的參數(shù)限制final，而訪問外部類的屬性就可以隨意

內部類中是保存著一個指向外部類實例的引用，內部類訪問外部類的成員變量都是通過這個引用。

在內部類修改了這個引用的數(shù)據(jù)，外部類再獲取時拿到的數(shù)據(jù)是一致的！

那當你在匿名內部類里面嘗試改變外部基本類型的變量的值的時候，或者改變外部引用變量的指向的時候，表面上看起來好像都成功了，但實際上并不會影響到外部的變量。所以，Java為了不讓自己看起來那么奇怪，才加了這個final的限制。

參考資料：

java為什么匿名內部類的參數(shù)引用時final？https://www.zhihu.com/question/21395848

一、char和varchar的區(qū)別

char是固定長度，varchar長度可變。varchar：如果原先存儲的位置無法滿足其存儲的需求，就需要一些額外的操作，根據(jù)存儲引擎的不同，有的會采用拆分機制，有的采用分頁機制。

char和varchar的存儲字節(jié)由具體的字符集來決定(之前寫錯了);

char是固定長度，長度不夠的情況下，用空格代替。varchar表示的是實際長度的數(shù)據(jù)類型

選用考量：

如果字段長度較短和字符間長度相近甚至是相同的長度，會采用char字符類型

二、多個線程順序打印問題

三個線程分別打印A，B，C，要求這三個線程一起運行，打印n次，輸出形如“ABCABCABC....”的字符串。

原博主給出了4種方式，我認為信號量這種方式比較簡單和容易理解，我這里粘貼一下(具體的可到原博主下學習)..

public class PrintABCUsingSemaphore {
    private int times;
    private Semaphore semaphoreA = new Semaphore(1);
    private Semaphore semaphoreB = new Semaphore(0);
    private Semaphore semaphoreC = new Semaphore(0);

    public PrintABCUsingSemaphore(int times) {
        this.times = times;
    }

    public static void main(String[] args) {
        PrintABCUsingSemaphore printABC = new PrintABCUsingSemaphore(10);

        // 非靜態(tài)方法引用  x::toString   和() -> x.toString() 是等價的！
        new Thread(printABC::printA).start();
        new Thread(printABC::printB).start();
        new Thread(printABC::printC).start();

        /*new Thread(() -> printABC.printA()).start();
        new Thread(() -> printABC.printB()).start();
        new Thread(() -> printABC.printC()).start();
*/
    }

    public void printA() {
        try {
            print("A", semaphoreA, semaphoreB);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void printB() {
        try {
            print("B", semaphoreB, semaphoreC);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void printC() {
        try {
            print("C", semaphoreC, semaphoreA);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void print(String name, Semaphore current, Semaphore next)
            throws InterruptedException {
        for (int i = 0; i < times; i++) {
            current.acquire();
            System.out.print(name);
            next.release();
        }
    }
}

作者：cheergoivan

鏈接：https://www.jianshu.com/p/40078ed436b4

來源：簡書

2018年9月14日18:15:36 yy筆試題就出了..

三、生產者和消費者

在不少的面經都能看到它的身影哈~~~基本都是要求能夠手寫代碼的。

其實邏輯并不難，概括起來就兩句話：

從生產者角度：如果公共隊列滿了(while循環(huán)判斷是否滿)，則等待。如果公共隊列沒滿，則生產數(shù)據(jù)并喚醒消費者進行消費。

從消費者角度：如果公共隊列空了(while循環(huán)判斷是否空)，則等待。如果公共隊列沒空，則消費數(shù)據(jù)并喚醒生產者進行生產。

基于原作者的代碼，我修改了部分并給上我認為合適的注釋(下面附上了原作者出處，感興趣的同學可到原文學習)

生產者：

import java.util.Random;
import java.util.Vector;
import java.util.concurrent.atomic.AtomicInteger;

public class Producer implements Runnable {

    // true--->生產者一直執(zhí)行，false--->停掉生產者
    private volatile boolean isRunning = true;

    // 公共資源
    private final Vector sharedQueue;

    // 公共資源的最大數(shù)量
    private final int SIZE;

    // 生產數(shù)據(jù)
    private static AtomicInteger count = new AtomicInteger();

    public Producer(Vector sharedQueue, int SIZE) {
        this.sharedQueue = sharedQueue;
        this.SIZE = SIZE;
    }

    @Override
    public void run() {
        int data;
        Random r = new Random();

        System.out.println("start producer id = " + Thread.currentThread().getId());
        try {
            while (isRunning) {
                // 模擬延遲
                Thread.sleep(r.nextInt(1000));

                // 當隊列滿時阻塞等待
                while (sharedQueue.size() == SIZE) {
                    synchronized (sharedQueue) {
                        System.out.println("Queue is full, producer " + Thread.currentThread().getId()
                                + " is waiting, size：" + sharedQueue.size());
                        sharedQueue.wait();
                    }
                }

                // 隊列不滿時持續(xù)創(chuàng)造新元素
                synchronized (sharedQueue) {
                    // 生產數(shù)據(jù)
                    data = count.incrementAndGet();
                    sharedQueue.add(data);

                    System.out.println("producer create data:" + data + ", size：" + sharedQueue.size());
                    sharedQueue.notifyAll();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupted();
        }
    }

    public void stop() {
        isRunning = false;
    }
}

消費者：

import java.util.Random;
import java.util.Vector;

public class Consumer implements Runnable {

    // 公共資源
    private final Vector sharedQueue;

    public Consumer(Vector sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {

        Random r = new Random();

        System.out.println("start consumer id = " + Thread.currentThread().getId());
        try {
            while (true) {
                // 模擬延遲
                Thread.sleep(r.nextInt(1000));

                // 當隊列空時阻塞等待
                while (sharedQueue.isEmpty()) {
                    synchronized (sharedQueue) {
                        System.out.println("Queue is empty, consumer " + Thread.currentThread().getId()
                                + " is waiting, size：" + sharedQueue.size());
                        sharedQueue.wait();
                    }
                }
                // 隊列不空時持續(xù)消費元素
                synchronized (sharedQueue) {
                    System.out.println("consumer consume data：" + sharedQueue.remove(0) + ", size：" + sharedQueue.size());
                    sharedQueue.notifyAll();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }
}

Main方法測試：

import java.util.Vector;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test2 {


    public static void main(String[] args) throws InterruptedException {

        // 1.構建內存緩沖區(qū)
        Vector sharedQueue = new Vector();
        int size = 4;

        // 2.建立線程池和線程
        ExecutorService service = Executors.newCachedThreadPool();
        Producer prodThread1 = new Producer(sharedQueue, size);
        Producer prodThread2 = new Producer(sharedQueue, size);
        Producer prodThread3 = new Producer(sharedQueue, size);
        Consumer consThread1 = new Consumer(sharedQueue);
        Consumer consThread2 = new Consumer(sharedQueue);
        Consumer consThread3 = new Consumer(sharedQueue);
        service.execute(prodThread1);
        service.execute(prodThread2);
        service.execute(prodThread3);
        service.execute(consThread1);
        service.execute(consThread2);
        service.execute(consThread3);

        // 3.睡一會兒然后嘗試停止生產者(結束循環(huán))
        Thread.sleep(10 * 1000);
        prodThread1.stop();
        prodThread2.stop();
        prodThread3.stop();

        // 4.再睡一會兒關閉線程池
        Thread.sleep(3000);

        // 5.shutdown()等待任務執(zhí)行完才中斷線程(因為消費者一直在運行的，所以會發(fā)現(xiàn)程序無法結束)
        service.shutdown();


    }
}

作者：我沒有三顆心臟

鏈接：https://www.jianshu.com/p/3f0cd7af370d

來源：簡書

另外，上面原文中也說了可以使用阻塞隊列來實現(xiàn)消費者和生產者。這就不用我們手動去寫wait/notify的代碼了，會簡單一丟丟。可以參考：

使用阻塞隊列解決生產者-消費者問題：https://www.cnblogs.com/chenpi/p/5553325.html

四、算法[1]

我現(xiàn)在需要實現(xiàn)一個棧，這個棧除了可以進行普通的push、pop操作以外，還可以進行getMin的操作，getMin方法被調用后，會返回當前棧的最小值，你會怎么做呢？你可以假設棧里面存的都是int整數(shù)

解決方案：

使用一個min變量來記住最小值，每次push的時候，看看是否需要更新min。

如果被pop出去的是min，第二次pop的時候，只能遍歷一下棧內元素，重新找到最小值。

總結：pop的時間復雜度是O(n)，push是O(1),空間是O(1)

使用輔助棧來存儲最小值。如果當前要push的值比輔助棧的min值要小，那在輔助棧push的值是最小值

總結：push和pop的時間復雜度都是O(1)，空間是O(n)。典型以空間換時間的例子。

import java.util.ArrayList;
import java.util.List;

public class MinStack {

    private List data = new ArrayList();
    private List mins = new ArrayList();

    public void push(int num) {
        data.add(num);
        if (mins.size() == 0) {
            // 初始化mins
            mins.add(num);
        } else {
            // 輔助棧mins每次push當時最小值
            int min = getMin();
            if (num >= min) {
                mins.add(min);
            } else {
                mins.add(num);
            }
        }
    }

    public int pop() {
        // 棧空，異常，返回-1
        if (data.size() == 0) {
            return -1;
        }
        // pop時兩棧同步pop
        mins.remove(mins.size() - 1);
        return data.remove(data.size() - 1);
    }

    public int getMin() {
        // 棧空，異常，返回-1
        if (mins.size() == 0) {
            return -1;
        }
        // 返回mins棧頂元素
        return mins.get(mins.size() - 1);
    }

}

繼續(xù)優(yōu)化：

棧為空的時候，返回-1很可能會帶來歧義(萬一人家push進去的值就有-1呢？)，這邊我們可以使用Java Exception來進行優(yōu)化

算法的空間優(yōu)化：上面的代碼我們可以發(fā)現(xiàn)：data棧和mins棧的元素個數(shù)總是相等的，mins棧中存儲幾乎都是最小的值(此部分是重復的!)

所以我們可以這樣做：當push的時候，如果比min棧的值要小的，才放進mins棧。同理，當pop的時候，如果pop的值是mins的最小值，mins才出棧，否則mins不出棧！

上述做法可以一定避免mins輔助棧有相同的元素！

但是，如果一直push的值是最小值，那我們的mins輔助棧還是會有大量的重復元素，此時我們可以使用索引(mins輔助棧存儲的是最小值索引，非具體的值)！

最終代碼：

import java.util.ArrayList;
import java.util.List;


public class MinStack {

    private List data = new ArrayList();
    private List mins = new ArrayList();

    public void push(int num) throws Exception {
        data.add(num);
        if(mins.size() == 0) {
            // 初始化mins
            mins.add(0);
        } else {
            // 輔助棧mins push最小值的索引
            int min = getMin();
            if (num < min) {
                mins.add(data.size() - 1);
            }
        }
    }

    public int pop() throws Exception {
        // 棧空，拋出異常
        if(data.size() == 0) {
            throw new Exception("棧為空");
        }
        // pop時先獲取索引
        int popIndex = data.size() - 1;
        // 獲取mins棧頂元素，它是最小值索引
        int minIndex = mins.get(mins.size() - 1);
        // 如果pop出去的索引就是最小值索引，mins才出棧
        if(popIndex == minIndex) {
            mins.remove(mins.size() - 1);
        }
        return data.remove(data.size() - 1);
    }

    public int getMin() throws Exception {
        // 棧空，拋出異常
        if(data.size() == 0) {
            throw new Exception("棧為空");
        }
        // 獲取mins棧頂元素，它是最小值索引
        int minIndex = mins.get(mins.size() - 1);
        return data.get(minIndex);
    }

}

參考資料：

【面試現(xiàn)場】如何實現(xiàn)可以獲取最小值的棧？

作者：channingbreeze 出處：互聯(lián)網偵察

五、多線程下的HashMap

眾所周知，HashMap不是一個線程安全的類。但有可能在面試的時候會被問到：如果在多線程環(huán)境下使用HashMap會有什么現(xiàn)象發(fā)生呢？？

結論：

put()的時候導致的多線程數(shù)據(jù)不一致(丟失數(shù)據(jù))

resize()操作會導致環(huán)形鏈表

jdk1.8已解決環(huán)鏈的問題(聲明兩對指針，維護兩個連鏈表)

fail-fast機制，對當前HashMap同時進行刪除/修改會拋出ConcurrentModificationException異常

參考資料：

談談HashMap線程不安全的體現(xiàn)：http://www.importnew.com/22011.html

jdk1.8 hashmap多線程put不會造成死循環(huán):https://blog.csdn.net/qq_27007251/article/details/71403647

六、Spring和Springboot區(qū)別

一、SpringBoot是能夠創(chuàng)建出獨立的Spring應用程序的

二、簡化Spring配置

Spring由于其繁瑣的配置，一度被人成為“配置地獄”，各種XML、Annotation配置，讓人眼花繚亂，而且如果出錯了也很難找出原因。

Spring Boot項目就是為了解決配置繁瑣的問題，最大化的實現(xiàn)convention over configuration(約定大于配置)。

提供一系列的依賴包來把其它一些工作做成開箱即用其內置一個’Starter POM’，對項目構建進行了高度封裝，最大化簡化項目構建的配置。

三、嵌入式Tomcat，Jetty容器，無需部署WAR包

七、G1和CMS

G1收集器的設計目標是取代CMS收集器，它同CMS相比，在以下方面表現(xiàn)的更出色：

G1是一個有整理內存過程的垃圾收集器，不會產生很多內存碎片。

CMS采用的是標記清除垃圾回收算法，可能會產生不少的內存碎片

G1的Stop The World(STW)更可控，G1在停頓時間上添加了預測機制，用戶可以指定期望停頓時間。

拓展閱讀：

G1 垃圾收集器介紹：https://javadoop.com/post/g1

八、海量數(shù)據(jù)解決方案

海量數(shù)據(jù)的處理也是一個經常考的知識點，無論在面試還是在筆試中都是比較常見的。有幸讀了下面的文章，摘錄了一些解決海量數(shù)據(jù)的思路：

Bloom filter布隆過濾器

適用范圍：可以用來實現(xiàn)數(shù)據(jù)字典，進行數(shù)據(jù)的判重，或者集合求交集

Hashing

適用范圍：快速查找，刪除的基本數(shù)據(jù)結構，通常需要總數(shù)據(jù)量可以放入內存

bit-map

適用范圍：可進行數(shù)據(jù)的快速查找，判重，刪除，一般來說數(shù)據(jù)范圍是int的10倍以下

堆

適用范圍：海量數(shù)據(jù)前n大，并且n比較小，堆可以放入內存

雙層桶劃分----其實本質上就是【分而治之】的思想，重在“分”的技巧上！

適用范圍：第k大，中位數(shù)，不重復或重復的數(shù)字

數(shù)據(jù)庫索引

適用范圍：大數(shù)據(jù)量的增刪改查

倒排索引(Inverted index)

適用范圍：搜索引擎，關鍵字查詢

外排序

適用范圍：大數(shù)據(jù)的排序，去重

trie樹

適用范圍：數(shù)據(jù)量大，重復多，但是數(shù)據(jù)種類小可以放入內存

分布式處理 mapreduce

適用范圍：數(shù)據(jù)量大，但是數(shù)據(jù)種類小可以放入內存

詳細可參考原文：

十道海量數(shù)據(jù)處理面試題與十個方法大總結：https://blog.csdn.net/v_JULY_v/article/details/6279498

九、冪等性 9.1HTTP冪等性

昨天去做了一套筆試題，經典的HTTP中get/post的區(qū)別。今天回來搜了一下，發(fā)現(xiàn)跟之前的理解有點出入。

如果一個人一開始就做Web開發(fā)，很可能把HTML對HTTP協(xié)議的使用方式，當成HTTP協(xié)議的唯一的合理使用方式。從而犯了以偏概全的錯誤

單純以HTTP協(xié)議規(guī)范來說，可能我們之前總結出的GET/POST區(qū)別就沒用了。(但通讀完整篇文章，我個人認為：如果面試中有GET/POST區(qū)別，還是默認以Web開發(fā)場景下來回答較好，這也許是面試官想要的答案)

參考資料：

GET和POST有什么區(qū)別？及為什么網上的多數(shù)答案都是錯的。http://www.cnblogs.com/nankezhishi/archive/2012/06/09/getandpost.html

其中也學習到了冪等性這么一個概念，于是也做做筆記吧~~~

Methods can also have the property of “idempotence” in that (aside from error or expiration issues) the side-effects of N > 0 identical requests is the same as for a single request.

從定義上看，HTTP方法的冪等性是指一次和多次請求某一個資源應該具有同樣的副作用。

這里簡單說一下“副作用”的意思：指當你發(fā)送完一個請求以后，網站上的資源狀態(tài)沒有發(fā)生修改，即認為這個請求是無副作用的

HTTP的GET/POST/DELETE/PUT方法冪等的情況：

GET是冪等的，無副作用

比如我想要獲得訂單ID為2的訂單：http://localhost/order/2，使用GET多次獲取，這個ID為2的訂單(資源)是不會發(fā)生變化的！

DELETE/PUT是冪等的，有副作用

比如我想要刪除或者更新ID為2的訂單：http://localhost/order/2，使用PUT/DELETE多次請求，這個ID為2的訂單(資源)只會發(fā)生一次變化(是有副作用的)！但繼續(xù)多次刷新請求，訂單ID為2的最終狀態(tài)都是一致的

POST是非冪等的，有副作用的

比如我想要創(chuàng)建一個名稱叫3y的訂單：http://localhost/order，使用POST多次請求，此時可能就會創(chuàng)建多個名稱為3y的訂單,這個訂單(資源)是會多次變化的，每次請求的資源狀態(tài)都會變化！

題外話：

HTTP協(xié)議本身是一種面向資源的應用層協(xié)議，但對HTTP協(xié)議的使用實際上存在著兩種不同的方式：一種是RESTful的，它把HTTP當成應用層協(xié)議，比較忠實地遵守了HTTP協(xié)議的各種規(guī)定(充分利用了HTTP的方法)；另一種是SOA的，它并沒有完全把HTTP當成應用層協(xié)議，而是把HTTP協(xié)議作為了傳輸層協(xié)議，然后在HTTP之上建立了自己的應用層協(xié)議

參考資料：

理解HTTP冪等性http://www.cnblogs.com/weidagang2046/archive/2011/06/04/2063696.html#!comments

如何理解RESTful的冪等性http://blog.720ui.com/2016/restful_idempotent/

淺談HTTP中Get與Post的區(qū)別http://www.cnblogs.com/hyffffd/archive/2009/03/31/1426026.html

HTTP 請求中 POST 和 GET 請求的區(qū)別？https://www.zhihu.com/question/27622127/answer/37676304

9.2接口冪等性

在查閱資料的時候，可以發(fā)現(xiàn)很多博客都講了接口的冪等性。從上面我們也可以看出，POST方法是非冪等的。但我們可以通過一些手段來令POST方法的接口變成是冪等的。

說了那么多，那接口設計成冪等的好處是什么？？？？

舉個例子說一下非冪等的壞處：

3y大一的時候是要搶體育課的，但學校的搶課系統(tǒng)做得賊爛(延遲很高)。我想要搶到課，就開了10多個Chrome標簽頁去搶(即使某個Chrome標簽頁崩了，我還有另外的Chrome標簽頁是可用的)。我想搶到乒乓球或者羽毛球。

搶課時間一到，我就輪著點擊我要想搶的乒乓球或者羽毛球。如果系統(tǒng)設計得不好，這個請求是非冪等的(或者說事務控制得不好)，我手速足夠快&&網絡足夠好，那我很可能搶到了多次乒乓球或者羽毛球的課程了。(這是不合理的，一個人只能選一門課，而我搶到了多門或者多次重復的課)

涉及到商城的應用場景可能就是：用戶下了多個重復的訂單了

如果我的搶課接口是冪等的話，那就不會出現(xiàn)這個問題了。因為冪等是多次請求某一個資源應該具有同樣的副作用。

在數(shù)據(jù)庫后臺最多只會有一條記錄，不存在搶到多門課的現(xiàn)象了。

說白了，設計冪等性接口就是為了防止重復提交的(數(shù)據(jù)庫出現(xiàn)多條重復的數(shù)據(jù))！

網上有博主也分享了幾條常見解決重復提交的方案：

同步鎖（單線程，在集群可能會失效）

分布式鎖如redis（實現(xiàn)復雜）

業(yè)務字段加唯一約束（簡單）

令牌表+唯一約束（簡單推薦）---->實現(xiàn)冪等接口的一種手段

mysql的insert ignore或者on duplicate key update（簡單）

共享鎖+普通索引（簡單）

利用MQ或者Redis擴展（排隊）

其他方案如多版本控制MVCC 樂觀鎖悲觀鎖狀態(tài)機等。。

參考資料：

分布式系統(tǒng)接口冪等性http://blog.brucefeng.info/post/api-idempotent

如何避免下重復訂單https://www.jianshu.com/p/e618cc818432

關于接口冪等性的總結https://www.jianshu.com/p/6eba27f8fb03

使用數(shù)據(jù)庫唯一鍵實現(xiàn)事務冪等性http://www.caosh.me/be-tech/idempotence-using-unique-key/

API接口非冪等性問題及使用redis實現(xiàn)簡單的分布式鎖https://blog.csdn.net/rariki/article/details/50783819

最后

如果以上有理解錯的地方，或者說有更好的理解方式，希望大家不吝在評論區(qū)下留言。共同進步！

如果想看更多的原創(chuàng)技術文章，歡迎大家關注我的微信公眾號:Java3y。Java技術群討論：742919422。公眾號還有海量的視頻資源哦，關注即可免費領取。

GPU云服務器云服務器 java面試題社招java面試題 java場景面試題 java考研面試題

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/71845.html

結束了我短暫的秋招，說點自己的感受

摘要：總體來說，玄武科技的真的很熱情，為他們點個贊，雖然自己最后沒能去玄武科技，然后就是技術面非常簡單，面和高管面也都還好，不會有壓抑的感覺，總體聊得很愉快。該文已加入開源文檔：JavaGuide（一份涵蓋大部分Java程序員所需要掌握的核心知識）。地址:https://github.com/Snailclimb... 秋招歷程流水賬總結筆主大四準畢業(yè)生，在秋招末流比較幸運地進入了一家...

KoreyLee 2019-08-16 13:29 評論0 收藏0
【Java】廣州三本秋招經歷

摘要：具體的時間線從月中旬，我開始關注牛客網的秋招內推信息。直至十月中下旬結束秋招。之前也寫過自己在廣州找實習的經歷，那次把面試的過程都具體貼出來了。我今年就完美錯過了春招實習經歷。前言只有光頭才能變強離上次發(fā)文章已經快兩個月時間了，最近一直忙著秋招的事。今天是2018年10月22日，對于互聯(lián)網行業(yè)來說，秋招就基本結束了。我這邊的流程也走完了(不再筆試/面試了)，所以來寫寫我的秋招經歷...

qqlcbb 2019-08-16 13:29 評論0 收藏1
我的秋招復盤——回顧2022秋招經歷

摘要：接下來，我主要從三個階段回顧我的秋招，分別是前期中期尾聲。到了這里，我的秋招算是正式的塵埃落定了，簽完三方后，我的秋招結束了。四復盤總結這次的復盤主要是我自己整個秋招的歷程縮影，很多細節(jié)無法在一篇文章就說清楚。 ...

longshengwang 2021-11-22 09:34 評論0 收藏0
[算法總結] 搞定 BAT 面試——幾道常見的子符串算法題

摘要：第一種方法常規(guī)方法。如果不存在公共前綴，返回空字符串。注意假設字符串的長度不會超過。說明本題中，我們將空字符串定義為有效的回文串。示例輸入輸出一個可能的最長回文子序列為。數(shù)值為或者字符串不是一個合法的數(shù)值則返回。說明本文作者：wwwxmu 原文地址:https://www.weiweiblog.cn/13s... 作者的博客站點：https://www.weiweiblog.c...

chanjarster 2019-08-19 11:07 評論0 收藏0
大廠難進？(來自雙非非科班應屆生的自述信)

摘要：關于自己屆畢業(yè)生一本雙非學校，非科班可能和很多人一樣，因為小時候喜歡打游戲，所以大學一直想學編程，但因為種種原因，自己來到了一個硬件相關專業(yè)，但由于現(xiàn)實和興趣，自己又從事了軟件相關的工作。找實習實習對于之后的秋招來說，是非常非常重要的。 ...

jerryloveemily 2021-09-23 11:21 評論0 收藏1