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

CAS的實(shí)現(xiàn)如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;
    }
}

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

信號(hào)量要與一個(gè)鎖結(jié)合使用,當(dāng)前線程要先獲得這個(gè)鎖,然后等待與這個(gè)鎖相關(guān)聯(lián)的信號(hào)量,此時(shí)該鎖會(huì)被解鎖,其他線程可以搶到這個(gè)鎖,如果其他線程搶到了這個(gè)鎖,那他可以通知這個(gè)信號(hào)量,然后釋放該鎖,如果此時(shí)第一個(gè)線程搶到了該鎖,那么它將從等待處繼續(xù)執(zhí)行(應(yīng)用場(chǎng)景,將異步回調(diào)操作封裝為變?yōu)橥讲僮?避免回調(diào)地獄)

信號(hào)量與鎖相比的應(yīng)用場(chǎng)景不同,鎖是服務(wù)于共享資源的,而信號(hào)量是服務(wù)于多個(gè)線程間的執(zhí)行的邏輯順序的,鎖的效率更高一些.

線程上保存著ThreadLocalMap,每個(gè)ThreadLocal使用弱引用包裝作為Key存入這個(gè)Map里,當(dāng)線程被回收或者沒有其他地方引用ThreadLocal時(shí),ThreadLocal也會(huì)被回收進(jìn)而回收其保存的值

軟引用內(nèi)存不夠的時(shí)候會(huì)釋放

弱引用GC時(shí)釋放

虛引用,需要和一個(gè)引用隊(duì)列聯(lián)系在一起使用,引用了跟沒引用一樣,主要是用來跟GC做一些交互.

簡(jiǎn)單來說就是先把加載請(qǐng)求轉(zhuǎn)發(fā)到父加載器,父加載器失敗了,再自己試著加載

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

處于激活狀態(tài)的線程

棧中的對(duì)象

JNI棧中的對(duì)象

JNI中的全局對(duì)象

正在被用于同步的各種鎖對(duì)象

JVM自身持有的對(duì)象，比如系統(tǒng)類加載器等。

Android線程模型就是消息循環(huán),Looper關(guān)聯(lián)MessageQueue,不斷嘗試從MessageQueue取出Message來消費(fèi),這個(gè)過程可能會(huì)被它自己阻塞.

而Handler最終都調(diào)用enqueueMessage(Message,when)入隊(duì)的,延遲的實(shí)現(xiàn)時(shí)當(dāng)前是時(shí)間加上延遲時(shí)間給消息指定一個(gè)執(zhí)行的時(shí)間點(diǎn),然后在MessageQueue找到插入位置,此時(shí)會(huì)判斷是否需要喚醒線程來消費(fèi)消息以及更新下次需要暫停的時(shí)間.

Message知道要發(fā)到哪個(gè)Handler是因?yàn)镸essage把Handler保存到了target.

Message內(nèi)部使用鏈表進(jìn)行回收復(fù)用

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

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

RxJava的調(diào)度器(io(優(yōu)先級(jí)比低),密集計(jì)算線程(優(yōu)先級(jí)比高,用于執(zhí)行密集計(jì)算任務(wù)),安卓主線程, Looper創(chuàng)建(實(shí)際上內(nèi)部也是創(chuàng)建了Handler))

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

AsyncTask,內(nèi)部使用FutureTask實(shí)現(xiàn),通過Handler將結(jié)果轉(zhuǎn)發(fā)到主線程,默認(rèn)的Executor是共用的,如果同時(shí)執(zhí)行多個(gè)AsyncTask,就可能需要排隊(duì),但是可以手動(dòng)指定Executor解決這個(gè)問題,直接new匿名內(nèi)部類會(huì)保存外部類的引用,可能會(huì)導(dǎo)致內(nèi)存泄漏

Android線程模型提供的Handler和HandlerThread

使用IntentService

IntentService和Service的區(qū)別——沒什么區(qū)別,其實(shí)就是開了個(gè)HandlerThread,讓它不要在主線程跑耗時(shí)任務(wù)

建議看一下,這個(gè)可能會(huì)被問,不過我運(yùn)氣好沒被問到.

網(wǎng)上有很多相關(guān)的文章,可以自己結(jié)合源碼去看一下,如果能講個(gè)大概的話也是很加分的.

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

無法避免的內(nèi)存拷貝,基本類型數(shù)組,無法避免拷貝,因?yàn)镴VM不信任C層的任何內(nèi)存操作,特別是字符串操作,因?yàn)镴ava的字符串與C/C++的字符串所使用的數(shù)據(jù)類型是不一樣的C/C++使用char一個(gè)字節(jié)(1字節(jié)=8位)或wchar_t是四字節(jié).而jstring和jchar使用的是UTF-16編碼使用雙字節(jié).(Unicode是兼容ASCII,但不兼容GBK,需要自己轉(zhuǎn)換)

自己創(chuàng)建的局部引用一定要釋放,否則一直持有內(nèi)存泄漏

非局部引用方法返回后就會(huì)失效,除非創(chuàng)建全局引用,jclass是一個(gè)jobject,方法外圍使用時(shí)需要?jiǎng)?chuàng)建全局引用,jmethodID和jfiledID不需要.

JNI是通過Java方法映射到C函數(shù)實(shí)現(xiàn)的,如果使用這種方法,函數(shù)必須以C式接口導(dǎo)出(因?yàn)镃++會(huì)對(duì)名字做修飾處理),當(dāng)然也可以在JNI_OnLoad方法中注冊(cè).

JNIEnv是線程獨(dú)立的,JNI中使用pthread創(chuàng)建的線程沒有JNIEnv,需要AttachCurrentThread來獲取JNIEnv,不用時(shí)要DetachCurrentThread

數(shù)據(jù)報(bào),流模式,TCP可靠,包序不對(duì)會(huì)要求重傳,UDP不管,甚至不能保證送到

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

CA證書,中間機(jī)構(gòu),公鑰加密對(duì)稱秘鑰傳回服務(wù)端,一個(gè)明文一個(gè)加密,SSL層,中間人攻擊,參考link

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

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

刷題的話,建議去刷leetcode,題號(hào)在200以內(nèi)的,簡(jiǎn)單和中等難度,不建議刷困難,因?yàn)槊嬖嚨臅r(shí)候基本就不會(huì)出,沒人愿意在那里等你想一個(gè)半個(gè)小時(shí)的.

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

下面是我在網(wǎng)上收集或者是在實(shí)際中遇到過的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;
    }

刪除排序數(shù)組中的重復(fù)項(xiàng)

    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;
    }

數(shù)組中找到重復(fù)元素

n個(gè)長(zhǎng)為n的有序數(shù)組，求最大的n個(gè)數(shù)

用O(1)的時(shí)間復(fù)雜度刪除單鏈表中的某個(gè)節(jié)點(diǎn) 把后一個(gè)元素賦值給待刪除節(jié)點(diǎn)，這樣也就相當(dāng)于是刪除了當(dāng)前元素,只有刪除最后一個(gè)元素的時(shí)間為o(N)平均時(shí)間復(fù)雜度仍然為O(1)

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

刪除單鏈表的倒數(shù)第N個(gè)元素 兩個(gè)指針,第一個(gè)先走N步第二個(gè)再走,時(shí)間復(fù)雜度為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;
      }

從長(zhǎng)序列中找出前K大的數(shù)字

用數(shù)組實(shí)現(xiàn)雙頭棧

  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;
          }
      }

兩個(gè)鏈表求和，返回結(jié)果也用鏈表表示 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;
      }

交換鏈表兩兩節(jié)點(diǎn)

      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;
      }

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

      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;
      }

二叉樹某一層有多少個(gè)節(jié)點(diǎn)

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

  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;
  	}
  	
  	/**
  	 * 使用如內(nèi)部實(shí)現(xiàn)使用雙向鏈表的LinkedList容器實(shí)現(xiàn)的快排 
  	 */
  	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;
  	}

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

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