說道Java高級(jí)程序員面試題，網(wǎng)上肯定是有不少資料，但是大家找一找不難發(fā)現(xiàn)出問題，就是很多高級(jí)程序員面試題中都沒有答案，只有題目，所以我們還需要花費(fèi)大量的時(shí)間去搜集一些帶有題目和答案的面試匯總，為了大家的方便，小編今天就匯總了一些大廠的高級(jí)面試題，大家可以進(jìn)行參考：

1. Java如何開啟線程?怎么保證線程安全?

答：線程與進(jìn)程的區(qū)別：進(jìn)程是操作系統(tǒng)進(jìn)行資源分配的最小單元。線程是操作系統(tǒng)進(jìn)行任務(wù)分配的最小單元，線程隸屬于進(jìn)程。

如何開啟線程?1. 繼承Thread類，重寫run方法。2. 實(shí)現(xiàn)Runable接口，實(shí)現(xiàn)run方法。3. 實(shí)現(xiàn)Callable接口，實(shí)現(xiàn)call方法。通過FutureTask創(chuàng)建一個(gè)線程，獲取到線程執(zhí)行的返回值。4. 通過線程池來開啟線程。

怎么保證線程安全?核心思想就是加鎖：1. JVM提供的鎖，也就是Synchronized關(guān)鍵字。 2. JDK提供的各種鎖Lock.

2. Volatile和Synchronized有什么區(qū)別?Volatile能不能保證線程安全?DCL(Double Check Lock)單例為什么要加Volatile

答：1. Synchronize關(guān)鍵字，用來加鎖，Volatile只是保持亦是的線程可見性。通常適用于一個(gè)線程寫，多個(gè)線程讀的場(chǎng)景。

2. Volatile關(guān)鍵字不能保證線程安全，只能保證線程可見性，不能保證原子性。

3.Volatile防止指令重排，在DCL中，防上高并發(fā)情況下，指令重排造成的線程安全問題。

3.Java線程鎖機(jī)制是怎么樣的?偏向鎖、輕量級(jí)鎖、重量級(jí)鎖有什么區(qū)別?鎖機(jī)制是如何升級(jí)的?

答：1.Java的鎖就是在對(duì)象的Markword中記錄一個(gè)鎖狀態(tài)，無鎖、偏向鎖、輕量級(jí)鎖、重量級(jí)鎖對(duì)應(yīng)不同的鎖狀態(tài)。

2. Java的鎖機(jī)制就是根據(jù)資源竟?fàn)幍募ち页潭炔粩噙M(jìn)行鎖升級(jí)的過程。

4.談?wù)勀銓?duì)AQS的理解。AQS如何實(shí)現(xiàn)可重入鎖?

答：1. AQS是一個(gè)Java線程同步的框架，是JDK中很多鎖工具的核心實(shí)現(xiàn)框架。

2. 在AQS中，維護(hù)了一個(gè)信號(hào)量state和一個(gè)線程組成的雙向鏈表隊(duì)列，其中，這個(gè)線程隊(duì)列就是用來給線程排隊(duì)的，而state就像是一個(gè)紅綠燈，用來控制線程排隊(duì)或才放行的，在不同的場(chǎng)景下，有不同的意義。

3.在可重入鎖這個(gè)場(chǎng)景下，state就用來表示加鎖的次數(shù)，0表示無鎖，每加一次鎖state就加1，釋放鎖state就減1.

5.有A、B、C三個(gè)線程，如何保證三個(gè)線程同時(shí)執(zhí)行?如何在并發(fā)情況下保證三個(gè)線程依次執(zhí)行?如何保證三個(gè)線程有序交錯(cuò)進(jìn)行?

答：CountDownLatch，CylicBarrier，Semaphore

public class ThreadSafeDemo {
    public int count = 0;
    public void add(){
        count++;
    }

    public static void main(String[] args) throws InterruptedException{
        int size = 3;

        ThreadSafeDemo threadSafeDemo = new ThreadSafeDemo();
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for(int i=0;i<size;i++){
            new Thread(()->{
                try{
                    countDownLatch.await();
                    System.out.println(System.currentTimeMillis());
                    Thread.sleep(100);
                }catch (Exception ex){
                    ex.printStackTrace();
                }
            }).start();
        }

        Thread.sleep(5000);
        countDownLatch.countDown();
    }
}

public class OldThread2 {
    static volatile int tickts = 1;
    public static void main(String[] args){
        Thread t1 = new Thread(()->{
            while (true){
                if(tickts==1){
                    try {
                        Thread.sleep(100);
                        for(int i=0;i<10;i++){
                            System.out.println("a"+i);
                        }
                    }catch (InterruptedException ie){
                        ie.printStackTrace();
                    }
                    tickts=2;
                    return;
                }
            }
        });

        Thread t2 = new Thread(()->{
            while (true){
                if(tickts==2){
                    try {
                        Thread.sleep(100);
                        for(int i=0;i<10;i++){
                            System.out.println("b"+i);
                        }
                    }catch (InterruptedException ie){
                        ie.printStackTrace();
                    }
                    tickts=3;
                    return;
                }
            }
        });

        Thread t3 = new Thread(()->{
            while (true){
                if(tickts==3){
                    try {
                        Thread.sleep(100);
                        for(int i=0;i<10;i++){
                            System.out.println("c"+i);
                        }
                    }catch (InterruptedException ie){
                        ie.printStackTrace();
                    }
                    tickts=1;
                    return;
                }
            }
        });

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

public class OldThread {
    private static Semaphore s1 = new Semaphore(1);
    private static Semaphore s2 = new Semaphore(1);
    private static Semaphore s3 = new Semaphore(1);

    public static void main(String[] args){
        try {
            s1.acquire();
            s2.acquire();
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }

        new Thread(()->{
            while (true){
                try {
                    s1.acquire();
                }catch (InterruptedException iex){
                    iex.printStackTrace();
                }
                try {
                    Thread.sleep(500);
                }catch (InterruptedException ex2){
                    ex2.printStackTrace();
                }
                System.out.println("A");
                s2.release();
            }
        }).start();

        new Thread(()->{
            while (true){
                try {
                    s2.acquire();
                }catch (InterruptedException iex){
                    iex.printStackTrace();
                }
                try {
                    Thread.sleep(500);
                }catch (InterruptedException ex2){
                    ex2.printStackTrace();
                }
                System.out.println("B");
                s3.release();
            }
        }).start();

        new Thread(()->{
            while (true){
                try {
                    s3.acquire();
                }catch (InterruptedException iex){
                    iex.printStackTrace();
                }
                try {
                    Thread.sleep(500);
                }catch (InterruptedException ex2){
                    ex2.printStackTrace();
                }
                System.out.println("C");
                s1.release();
            }
        }).start();
    }
}

6. 如何對(duì)一個(gè)字符串快速進(jìn)行排序?

答：Fork/Join框架

public class MargeTest {
    private static int MAX = 100;

    private static int inits[] = new int[MAX];

    //隨機(jī)隊(duì)列初始化
    static {
        Random r = new Random();
        for(int index = 0; index<MAX;index++){
            inits[index-1] = r.nextInt(1000);
        }
    }

    public static void main(String[] args) throws Exception{
        long beginTime = System.currentTimeMillis();
        ForkJoinPool pool = new ForkJoinPool();
        MyTask task = new MyTask(inits);
        ForkJoinTask<int[]> taskResult = pool.submit(task);
        try {
            int[] ints = taskResult.get();
            System.out.println(Arrays.toString(ints));
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("耗時(shí)："+(endTime-beginTime));
    }

    static class MyTask extends RecursiveTask<int[]>{
        private int source[];

        public MyTask(int source[]){
            this.source = source;
        }

        @Override
        protected int[] compute() {
            int sourcelen = source.length;
            if(sourcelen>2){
                int midIndex = sourcelen/2;
                MyTask task1 = new MyTask(Arrays.copyOf(source,midIndex));
                task1.fork();
                MyTask task2 = new MyTask(Arrays.copyOfRange(source,midIndex,sourcelen));
                task2.fork();

                int result1[] = task1.join();
                int result2[] = task2.join();
                int mer[] = joinInts(result1,result2);
                return mer;
            }else{
                if(sourcelen==1 || source[0]<source[1]){
                    return source;
                }else{
                    int targetTp[] = new int[sourcelen];
                    targetTp[0] = source[1];
                    targetTp[1] = source[0];
                    return targetTp;
                }
            }
        }
    }
}

7. TCP和UDP有什么區(qū)別?TCP為什么是三次握手，而不是兩次?

答：TCP Transfer Control Protocol 是一種面向連接的，可靠的，傳輸層通信協(xié)議。

特點(diǎn)：好比打電話，面向連接的，點(diǎn)對(duì)點(diǎn)的通信，高可靠的，效率比較低，占用的系統(tǒng)資源比較多。

UDP User Datagram Protocol 是一種無連接的，不可靠的，傳輸層通信協(xié)議。

特點(diǎn)：好比廣播，不需要連接，發(fā)送方不管接收方有沒有準(zhǔn)備好，直接發(fā)消息;可以進(jìn)行廣播發(fā)送。傳輸不可靠，有可能丟失消息;效率比較高，協(xié)議比較簡(jiǎn)單，占用的系統(tǒng)資源比較少。

TCP建立連接三次握手，斷開連接四次揮手。如果是兩次握手，可能造成連接資源浪費(fèi)的情況。

8. Java有哪幾種IO模型?有什么區(qū)別?

答：

BIO 同步阻塞IO。可靠性差，吞吐量低，適用于連接比較少且比較固定的場(chǎng)景。JDK1.4之前唯一的選擇。編程模型最簡(jiǎn)單。

NIO 同步非阻塞IO。可靠性比較好，吞吐量比較高，適用于連接比較多，并且連接比較短(輕操作)，例如聊天室，編程模型最復(fù)雜。

AIO 異步非阻塞IO。可靠性是最好的，吞吐量也是非常高的，適用于連接比較多，并且連接比較長(zhǎng)(重操作)。例如相冊(cè)服務(wù)器。視頻流點(diǎn)播等，JDK1.7版本之后提供的。編程模型比較簡(jiǎn)單，需要操作系統(tǒng)來支持。

同步、異步【針對(duì)請(qǐng)求】和阻塞、非阻塞【針對(duì)客戶端】

在一個(gè)網(wǎng)絡(luò)請(qǐng)求中，客戶端會(huì)發(fā)一個(gè)請(qǐng)求到服務(wù)端。

1. 客戶端發(fā)了請(qǐng)求后，就一直等著服務(wù)端響應(yīng)。客戶端： 阻塞。 請(qǐng)求：同步

2. 客戶端發(fā)了請(qǐng)求后，就去干別的事情了，時(shí)不時(shí)過來檢查服務(wù)端是否給出了相應(yīng)。客戶端：非阻塞。請(qǐng)求：同步。

3. 換成異步請(qǐng)求。 客戶端發(fā)了請(qǐng)求后，就坐在椅子上，等著服務(wù)端返回響應(yīng)。客戶端：阻塞。 請(qǐng)求：異步。

4. 客戶端發(fā)了請(qǐng)求后，就去干別的事情了。等到服務(wù)端給出響應(yīng)后，再過來處理業(yè)務(wù)邏輯。 客戶端： 非阻塞。請(qǐng)求：異步。

以上就是“Java高級(jí)程序員面試題，內(nèi)含解析答案”，你能回答上來嗎?如果想要了解更多的Java面試題相關(guān)內(nèi)容，可以關(guān)注動(dòng)力節(jié)點(diǎn)Java官網(wǎng)。