數組加鏈表加紅黑樹,默認負載因子0.75,樹化閾值8,這部分比較常考,建議專門準備.(打個小廣告OWO,你也可以關注我的專欄,里面有一篇文章分析了HashMap和ArrayMap)

CAS的實現如AtomicInteger等等

雙重檢查

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {}

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

反序列化安全,反射安全 枚舉級單例,類加載時由JVM保證單例,反序列化不會生成新對象,另外一種反射安全是在構造函數中對單例進行檢查如果存在則拋出異常.

信號量要與一個鎖結合使用,當前線程要先獲得這個鎖,然后等待與這個鎖相關聯的信號量,此時該鎖會被解鎖,其他線程可以搶到這個鎖,如果其他線程搶到了這個鎖,那他可以通知這個信號量,然后釋放該鎖,如果此時第一個線程搶到了該鎖,那么它將從等待處繼續執行(應用場景,將異步回調操作封裝為變為同步操作,避免回調地獄)

信號量與鎖相比的應用場景不同,鎖是服務于共享資源的,而信號量是服務于多個線程間的執行的邏輯順序的,鎖的效率更高一些.

線程上保存著ThreadLocalMap,每個ThreadLocal使用弱引用包裝作為Key存入這個Map里,當線程被回收或者沒有其他地方引用ThreadLocal時,ThreadLocal也會被回收進而回收其保存的值

軟引用內存不夠的時候會釋放

弱引用GC時釋放

虛引用,需要和一個引用隊列聯系在一起使用,引用了跟沒引用一樣,主要是用來跟GC做一些交互.

簡單來說就是先把加載請求轉發到父加載器,父加載器失敗了,再自己試著加載

通過System Class Loader或者Boot Class Loader加載的class對象，通過自定義類加載器加載的class不一定是GC Root:

處于激活狀態的線程

棧中的對象

JNI棧中的對象

JNI中的全局對象

正在被用于同步的各種鎖對象

JVM自身持有的對象，比如系統類加載器等。

Android線程模型就是消息循環,Looper關聯MessageQueue,不斷嘗試從MessageQueue取出Message來消費,這個過程可能會被它自己阻塞.

而Handler最終都調用enqueueMessage(Message,when)入隊的,延遲的實現時當前是時間加上延遲時間給消息指定一個執行的時間點,然后在MessageQueue找到插入位置,此時會判斷是否需要喚醒線程來消費消息以及更新下次需要暫停的時間.

Message知道要發到哪個Handler是因為Message把Handler保存到了target.

Message內部使用鏈表進行回收復用

建議看《Android開發藝術探索》,這玩意三言兩語講不清楚

裸new一個Thread(失控線程,不推薦)

RxJava的調度器(io(優先級比低),密集計算線程(優先級比高,用于執行密集計算任務),安卓主線程, Looper創建(實際上內部也是創建了Handler))

Java Executor框架的Executors#newCachedThreadPool(),不會造成資源浪費,60秒沒有被使用的線程會被釋放

AsyncTask,內部使用FutureTask實現,通過Handler將結果轉發到主線程,默認的Executor是共用的,如果同時執行多個AsyncTask,就可能需要排隊,但是可以手動指定Executor解決這個問題,直接new匿名內部類會保存外部類的引用,可能會導致內存泄漏

Android線程模型提供的Handler和HandlerThread

使用IntentService

IntentService和Service的區別——沒什么區別,其實就是開了個HandlerThread,讓它不要在主線程跑耗時任務

建議看一下,這個可能會被問,不過我運氣好沒被問到.

網上有很多相關的文章,可以自己結合源碼去看一下,如果能講個大概的話也是很加分的.

可避免的內存拷貝,直接傳遞對象,到C層是一個jobject的指針,可以使用jmethodID和jfiledID訪問方法和字段,無需進行內存拷貝,使用直接緩沖區也可以避免內存拷貝.

無法避免的內存拷貝,基本類型數組,無法避免拷貝,因為JVM不信任C層的任何內存操作,特別是字符串操作,因為Java的字符串與C/C++的字符串所使用的數據類型是不一樣的C/C++使用char一個字節(1字節=8位)或wchar_t是四字節.而jstring和jchar使用的是UTF-16編碼使用雙字節.(Unicode是兼容ASCII,但不兼容GBK,需要自己轉換)

自己創建的局部引用一定要釋放,否則一直持有內存泄漏

非局部引用方法返回后就會失效,除非創建全局引用,jclass是一個jobject,方法外圍使用時需要創建全局引用,jmethodID和jfiledID不需要.

JNI是通過Java方法映射到C函數實現的,如果使用這種方法,函數必須以C式接口導出(因為C++會對名字做修飾處理),當然也可以在JNI_OnLoad方法中注冊.

JNIEnv是線程獨立的,JNI中使用pthread創建的線程沒有JNIEnv,需要AttachCurrentThread來獲取JNIEnv,不用時要DetachCurrentThread

數據報,流模式,TCP可靠,包序不對會要求重傳,UDP不管,甚至不能保證送到

這個被問的幾率非常的大,幾乎等于必問,建議專門花時間去看.

CA證書,中間機構,公鑰加密對稱秘鑰傳回服務端,一個明文一個加密,SSL層,中間人攻擊,參考link

對于ACM,比較常考鏈表的題,不常刷算法的同學一定不要對其有抵觸心理.

你可能會問為什么要ACM");

刷題的話,建議去刷leetcode,題號在200以內的,簡單和中等難度,不建議刷困難,因為面試的時候基本就不會出,沒人愿意在那里等你想一個半個小時的.

在面試官面前現場白板編程時,可以先把思路告訴面試官,寫不寫得出來是另外一回事,時間復雜度和空間復雜度是怎么來的一定要搞清楚.在編碼時也不一定要寫出最佳的時間和空間的算法,但推薦你寫出代碼量最少,思路最清晰的,這樣面試官看得舒服,你講得也舒服.

下面是我在網上收集或者是在實際中遇到過的ACM題,基本上在leetcode上也都有類似的.

鏈表逆序(頭條幾乎是必考的)

    public ListNode reverseList(ListNode head)
    {
        if (head == null)
        {
            return null;
        }
        if (head.next == null)
        {
            return head;
        }
        ListNode prev = null;
        ListNode current = head;
        while (current != null)
        {
            ListNode next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        return prev;
    }

刪除排序數組中的重復項

    public int removeDuplicates(int[] nums)
    {
        int length = nums.length;
        if (length == 0 || length == 1)
        {
            return length;
        }
        int size = 1;
        int pre = nums[0];
        for (int i = 1; i < length; )
        {
            if (nums[i] == pre)
            {
                i++;
            } else
            {
                pre = nums[size++] = nums[i++];
            }
        }
        return size;
    }

數組中找到重復元素

n個長為n的有序數組，求最大的n個數

用O(1)的時間復雜度刪除單鏈表中的某個節點 把后一個元素賦值給待刪除節點，這樣也就相當于是刪除了當前元素,只有刪除最后一個元素的時間為o(N)平均時間復雜度仍然為O(1)

      public void deleteNode(ListNode node) {
          ListNode next = node.next;
          node.val = next.val;
          node.next = next.next;
      }

刪除單鏈表的倒數第N個元素 兩個指針,第一個先走N步第二個再走,時間復雜度為O(N),參考link

      public ListNode removeNthFromEnd(ListNode head, int n) {
          if (head == null)
          {
              return null;
          }
          if (head.next == null)
          {
              return n == 1 ");do
          {
              if (size >= n + 1)
              {
                  point = point.next;
              }
              node = node.next;
              size++;
          } while (node != null);
          if (size == n)
          {
              return head.next;
          }
          node = point.next;
          point.next = node == null ");return head;
      }

從長序列中找出前K大的數字

用數組實現雙頭棧

  public static class Stack
      {
          
          public Stack(int cap)
          {
              if (cap <= 0)
              {
                  throw new IllegalArgumentException();
              }
              array = new Object[cap];
              left = 0;
              right = cap - 1;
          }
  
          private Object[] array;
          private int left;
          private int right;
          
          public void push1(T val)
          {
              int index = left + 1;
              if (index < right)
              {
                  array[index] = val;
              }
              left = index;
          }
          
          @SuppressWarnings("unchecked")
          public T pop1()
          {
              if (left > 0)
              {
                  return (T)array[left--];
              }
              return null;
          }
          
          public void push2(T val)
          {
              int index = right - 1;
              if (index > left)
              {
                  array[index] = val;
              }
              right = index;
          }
  
          @SuppressWarnings("unchecked")
          public T pop2()
          {
              if (right < array.length)
              {
                 return (T)array[right++];
              }
              return null;
          }
      }

兩個鏈表求和，返回結果也用鏈表表示 1 -> 2 -> 3 + 2 -> 3 -> 4 = 3 -> 5 -> 7

      public ListNode addTwoNumbers(ListNode node1, ListNode node2)
      {
          ListNode head = null;
          ListNode tail = null;
          boolean upAdd = false;
          while (!(node1 == null && node2 == null))
          {
              ListNode midResult = null;
              if (node1 != null)
              {
                  midResult = node1;
                  node1 = node1.next;
              }
              if (node2 != null)
              {
                  if (midResult == null)
                  {
                      midResult = node2;
                  } else
                  {
                      midResult.val += node2.val;
                  }
                  node2 = node2.next;
              }
              if (upAdd)
              {
                  midResult.val += 1;
              }
              if (midResult.val >= 10)
              {
                  upAdd = true;
                  midResult.val %= 10;
              }
              else
              {
                  upAdd = false;
              }
              if (head == null)
              {
                  head = midResult;
                  tail = midResult;
              } else
              {
                  tail.next = midResult;
                  tail = midResult;
              }
          }
          if (upAdd)
          {
              tail.next = new ListNode(1);
          }
          return head;
      }

交換鏈表兩兩節點

      public ListNode swapPairs(ListNode head)
      {
          if (head == null)
          {
              return null;
          }
          if (head.next == null)
          {
              return head;
          }
          ListNode current = head;
          ListNode after = current.next;
          ListNode nextCurrent;
          head = after;
          do
          {
              nextCurrent = after.next;
              after.next = current;
              if (nextCurrent == null)
              {
                  current.next = null;
                  break;
              }
              current.next = nextCurrent.next;
              after = nextCurrent.next;
              if (after == null)
              {
                  current.next = nextCurrent;
                  break;
              }
              current = nextCurrent;
          } while (true);
          return head;
      }

找出數組中和為給定值的兩個元素，如：[1, 2, 3, 4, 5]中找出和為6的兩個元素。

      public int[] twoSum(int[]mun,int target)
      {
          Map table = new HashMap<>();
          for (int i = 0; i < mun.length; ++i)
          {
              Integer value = table.get(target - mun[i]);
              if (value != null)
              {
                  return new int[]{i, value};
              }
              table.put(mun[i], i);
          }
          return null;
      }

二叉樹某一層有多少個節點

雙向鏈表排序(這個就比較過分了,遇到了就自求多福吧)

  public static void quickSort(Node head, Node tail) {
  		if (head == null || tail == null || head == tail || head.next == tail) {
  			return;
  		}
  		
  		if (head != tail) {
  			Node mid = getMid(head, tail);
  			quickSort(head, mid);
  			quickSort(mid.next, tail);
  		}
  	}
  	
  	public static Node getMid(Node start, Node end) {
  		int base = start.value;
  		while (start != end) {
  			while(start != end && base <= end.value) {
  				end = end.pre;
  			}
  			start.value = end.value;
  			while(start != end && base >= start.value) {
  				start = start.next;
  			}
  			end.value = start.value;
  		}
  		start.value = base;
  		return start;
  	}
  	
  	/**
  	 * 使用如內部實現使用雙向鏈表的LinkedList容器實現的快排 
  	 */
  	public static void quickSort(List list) {
  		if (list == null || list.isEmpty()) {
  			return;
  		}
  		quickSort(list, 0, list.size() - 1);
  	}
  	
  	private static void quickSort(List list, int i, int j) {
  		if (i < j) {
  			int mid = partition(list, i, j);
  			partition(list, i, mid);
  			partition(list,mid + 1, j);
  		}
  	}
  	
  	private static int partition(List list, int i, int j) {
  		int baseVal = list.get(i);
  		while (i < j) {
  			while (i < j && baseVal <= list.get(j)) {
  				j--;
  			}
  			list.set(i, list.get(j));
  			while (i < j && baseVal >= list.get(i)) {
  				i++;
  			}
  			list.set(j, list.get(i));
  		}
  		list.set(i, baseVal);
  		return i;
  	}

常見排序,如堆排序,快速,歸并,冒泡等,還得記住他們的時間復雜度.

不要答TCP,答RTMP實時傳輸協議,RTMP在Github也有很多開源實現,建議面這方面的同學可以去了解一下.