15個頂級多線程面試題及答案

https://www.cnblogs.com/starcrm/p/5010336.html定時線程池中scheduleWithFixedDelay和scheduleAtFixedRate

 

轉自https://www.cnblogs.com/huajiezh/p/5790942.html 

1)現在有T1、T2、T3三個線程，你怎樣保證T2在T1執行完后執行，T3在T2執行完后執行？

這個線程問題通常會在第一輪或電話面試階段被問到，目的是檢測你對”join”方法是否熟悉。這個多線程問題比較簡單，可以用join方法實現。

不錯的鏈接講解  鏈接x=https://blog.csdn.net/u010983881/article/details/80257703

有趣的是，第一個運行結果大概率是這樣的。說明沒主線程會搶嗎，。，

第二個運行結果是這樣的

 

 

猜想是這樣的：指令做了重新排序，或者看看源碼去，現在能力弱雞，還是先別看。以上兩張圖說明會把主線程先運行完再去運行子線程的東西。從下面的運行看，是和主線程搶的太少了，線程多的時候，嘿嘿主線程就多掛會把。

而join會把當前正在被調用的線程阻塞直到調用的線程運行完畢。當設置了join(time)時間的時候，time過了，不管threadA有沒有執行完都會回到主線程.如下，上面join(500)的結果

所以T1-->T2-->T3,  

 

 

 

 

 

 

 

 

右圖是代碼，開始是無序執行的，解開注釋代碼后，就是有序的了。join拿到主線程，讓自己先運行完，然后回到主線程。  

 外記，創建線程用的是鏈接中顯示創建，阿里給的提示 

 

2 在Java中Lock接口比synchronized塊的優勢是什么？你需要實現一個高效的緩存，它允許多個用戶讀，但只允許一個用戶寫，以此來保持它的完整性，你會怎樣去實現它？

lock鎖參考1 　　　　https://www.cnblogs.com/dolphin0520/p/3923167.html  

多個用戶讀，一個用戶寫：   https://www.cnblogs.com/XinHuai/p/6830790.html

外記  synchronized和ReentrantLock都是可重入鎖

總結來說，Lock和synchronized有以下幾點不同：

　　1）Lock是一個接口，而synchronized是Java中的關鍵字，synchronized是內置的語言實現；

　　2）synchronized在發生異常時，會自動釋放線程占有的鎖，因此不會導致死鎖現象發生；而Lock在發生異常時，如果沒有主動通過unLock()去釋放鎖，則很可能造成死鎖現象，因此使用Lock時需要在finally塊中釋放鎖；

　　3）Lock可以讓等待鎖的線程響應中斷，而synchronized卻不行，使用synchronized時，等待的線程會一直等待下去，不能夠響應中斷；      lock的優勢1

　　4）通過Lock可以知道有沒有成功獲取鎖，而synchronized卻無法辦到。   優勢2

　　5）Lock可以提高多個線程進行讀操作的效率。　　優勢3

　　在性能上來說，如果競爭資源不激烈，兩者的性能是差不多的，而當競爭資源非常激烈時（即有大量線程同時競爭），此時Lock的性能要遠遠優於synchronized。所以說，在具體使用時要根據適當情況選擇。

3)在java中wait和sleep方法的不同？

最大的不同是在等待時wait會釋放鎖，而sleep一直持有鎖。Wait通常被用於線程間交互，sleep通常被用於暫停執行。

4）用Java實現阻塞隊列

https://www.cnblogs.com/huojg-21442/p/7119727.html     阻塞隊列實現1

https://www.cnblogs.com/dolphin0520/p/3932906.html   心情不爽，沒看了

5）用Java寫代碼來解決生產者——消費者問題。

http://www.cnblogs.com/moongeek/p/7631447.html

https://www.cnblogs.com/jiangyang/p/6007030.html

1 wait/notify

package one.threadLearn.productAndCustomer.one;

public class Hosee {
    private static Integer count = 0;
    private final Integer  FULL  = 10;
    private static String  LOCK  = "LOCK";

    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == FULL) {
                        try {
                            System.out.println("倉庫滿了");
                            LOCK.wait();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    count++;
                    System.out.println(Thread.currentThread().getName() + "生產者生產，目前總共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }

    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                synchronized (LOCK) {
                    while (count == 0) {
                        try {
                            System.out.println("庫存空了");
                            LOCK.wait();
                        } catch (Exception e) {
                        }
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "消費者消費，目前總共有" + count);
                    LOCK.notifyAll();
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Hosee hosee = new Hosee();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Consumer()).start();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Consumer()).start();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Consumer()).start();
        new Thread(hosee.new Producer()).start();
        new Thread(hosee.new Consumer()).start();
    }
}

6）用Java編程一個會導致死鎖的程序，你將怎么解決？

 

7) 什么是原子操作，Java中的原子操作是什么？

 

8) Java中的volatile關鍵是什么作用？怎樣使用它？在Java中它跟synchronized方法有什么不同？

 

 

9) 什么是競爭條件？你怎樣發現和解決競爭？

 

 

10) 你將如何使用thread dump？你將如何分析Thread dump？

 

11) 為什么我們調用start()方法時會執行run()方法，為什么我們不能直接調用run()方法？

 

12) Java中你怎樣喚醒一個阻塞的線程？

 

 

13)在Java中CycliBarriar和CountdownLatch有什么區別？

 

14) 什么是不可變對象，它對寫並發應用有什么幫助？

 

 

15) 你在多線程環境中遇到的共同的問題是什么？你是怎么解決它的？

 

 

 

 

https://www.javazhiyin.com/category/thread