標記清楚演算法是同步的嗎_JVM有哪些垃圾回收演算法

㈠誤標記清除成功後手機還顯示標記信息為什麼

（1）手機終端不是實時與標記服務後台進行數據同步，存在幾天不等的延時。
（2）部分版本較低的手機終端和應用無法自動與標記服務後台進行數據同步，需要手工更新手機終端操作系統或標記APP應用數據。
（3）部分手機終端需要手工清除緩存數據，即刪除本機與被標記號碼的通話記錄，重啟手機。
（4）標記清除後很快又有新標記產生。

㈡ Web前端崗位面試題有哪些

前端面試題匯總，基本上會有四大類問題，具體如下：
一、HTML

1、Doctype作用？嚴格模式與混雜模式如何區分？它們有何意義?

2、HTML5 為什麼只需要寫 <!DOCTYPE HTML>？
3、行內元素有哪些？塊級元素有哪些？空(void)元素有那些？
4、頁面導入樣式時，使用link和@import有什麼區別？
5、介紹一下你對瀏覽器內核的理解？
6、常見的瀏覽器內核有哪些？
7、html5有哪些新特性、移除了那些元素？如何處理HTML5新標簽的瀏覽器兼容問題？如何區分 HTML 和 HTML5？
8、簡述一下你對HTML語義化的理解？
9、HTML5的離線儲存怎麼使用，工作原理能不能解釋一下？
10、瀏覽器是怎麼對HTML5的離線儲存資源進行管理和載入的呢？
11、請描述一下 cookies，sessionStorage 和 localStorage 的區別？
12、iframe有那些缺點？
13、Label的作用是什麼？是怎麼用的？（加 for 或包裹）
14、HTML5的form如何關閉自動完成功能？
15、如何實現瀏覽器內多個標簽頁之間的通信? (阿里)
16、webSocket如何兼容低瀏覽器？(阿里)
17、頁面可見性（Page Visibility）API 可以有哪些用途？
18、如何在頁面上實現一個圓形的可點擊區域？
19、實現不使用 border 畫出1px高的線，在不同瀏覽器的Quirksmode和CSSCompat模式下都能保持同一效果。
20、網頁驗證碼是幹嘛的，是為了解決什麼安全問題？
21、tite與h1的區別、b與strong的區別、i與em的區別？

二、css

1、介紹一下標準的CSS的盒子模型？與低版本IE的盒子模型有什麼不同的？

2、CSS選擇符有哪些？哪些屬性可以繼承？
3、CSS優先順序演算法如何計算？
4、CSS3新增偽類有那些？
5、如何居中div？如何居中一個浮動元素？如何讓絕對定位的div居中？
6、display有哪些值？說明他們的作用。
7、position的值relative和absolute定位原點是？
8、CSS3有哪些新特性？
9、請解釋一下CSS3的Flexbox（彈性盒布局模型）,以及適用場景？
10、用純CSS創建一個三角形的原理是什麼？

11、一個滿屏品字布局如何設計?

三、常見兼容性問題？

1、li與li之間有看不見的空白間隔是什麼原因引起的？有什麼解決辦法？
2、經常遇到的瀏覽器的兼容性有哪些？原因，解決方法是什麼，常用hack的技巧？
3、為什麼要初始化CSS樣式。
4、absolute的containing block計算方式跟正常流有什麼不同？
5、CSS里的visibility屬性有個collapse屬性值是幹嘛用的？在不同瀏覽器下以後什麼區別？
6、position跟display、margin collapse、overflow、float這些特性相互疊加後會怎麼樣？
7、對BFC規范(塊級格式化上下文：block formatting context)的理解？
8、CSS權重優先順序是如何計算的？
9、請解釋一下為什麼會出現浮動和什麼時候需要清除浮動？清除浮動的方式
10、移動端的布局用過媒體查詢嗎？
11、使用 CSS 預處理器嗎？喜歡那個？
12、CSS優化、提高性能的方法有哪些？
13、瀏覽器是怎樣解析CSS選擇器的？
14、在網頁中的應該使用奇數還是偶數的字體？為什麼呢？
15、margin和padding分別適合什麼場景使用？
16、抽離樣式模塊怎麼寫，說出思路，有無實踐經驗？[阿里航旅的面試題]
17、元素豎向的百分比設定是相對於容器的高度嗎？
18、全屏滾動的原理是什麼？用到了CSS的那些屬性？
19、什麼是響應式設計？響應式設計的基本原理是什麼？如何兼容低版本的IE？
20、視差滾動效果，如何給每頁做不同的動畫？（回到頂部，向下滑動要再次出現，和只出現一次分別怎麼做？）
21、::before 和 :after中雙冒號和單冒號有什麼區別？解釋一下這2個偽元素的作用。
22、如何修改chrome記住密碼後自動填充表單的黃色背景？
23、你對line-height是如何理解的？
24、設置元素浮動後，該元素的display值是多少？（自動變成display:block）
25、怎麼讓Chrome支持小於12px 的文字？
26、讓頁面里的字體變清晰，變細用CSS怎麼做？（-webkit-font-smoothing: antialiased;）
27、font-style屬性可以讓它賦值為「oblique」 oblique是什麼意思？
28、position:fixed;在android下無效怎麼處理？
29、如果需要手動寫動畫，你認為最小時間間隔是多久，為什麼？（阿里）
30、display:inline-block 什麼時候會顯示間隙？(攜程)
31、overflow: scroll時不能平滑滾動的問題怎麼處理？
32、有一個高度自適應的div，裡面有兩個div，一個高度100px，希望另一個填滿剩下的高度。
33、png、jpg、gif 這些圖片格式解釋一下，分別什麼時候用。有沒有了解過webp？
34、什麼是Cookie 隔離？（或者說：請求資源的時候不要讓它帶cookie怎麼做）
35、style標簽寫在body後與body前有什麼區別？

四、javaScript

1、介紹JavaScript的基本數據類型。
2、說說寫JavaScript的基本規范？
3、JavaScript原型，原型鏈 ? 有什麼特點？
4、JavaScript有幾種類型的值？（堆：原始數據類型和棧：引用數據類型），你能畫一下他們的內存圖嗎？
5、Javascript如何實現繼承？
6、Javascript創建對象的幾種方式？
7、Javascript作用鏈域?
8、談談This對象的理解。
9、eval是做什麼的？
10、什麼是window對象? 什麼是document對象?
11、null，undefined的區別？
12、寫一個通用的事件偵聽器函數(機試題)。
13、[「1」, 「2」, 「3」].map(parseInt) 答案是多少？
14、關於事件，IE與火狐的事件機制有什麼區別？如何阻止冒泡？
15、什麼是閉包（closure），為什麼要用它？
16、javascript 代碼中的」use strict」;是什麼意思 ? 使用它區別是什麼？
17、如何判斷一個對象是否屬於某個類？
18、new操作符具體幹了什麼呢?
19、用原生JavaScript的實現過什麼功能嗎？
20、Javascript中，有一個函數，執行時對象查找時，永遠不會去查找原型，這個函數是？
21、對JSON的了解？
22、[].forEach.call($$("*"),function(a){ a.style.outline="1px solid #"+(~~(Math.random()*(1<<24))).toString(16) }) 能解釋一下這段代碼的意思嗎？
23、js延遲載入的方式有哪些？
24、Ajax 是什麼? 如何創建一個Ajax？
25、同步和非同步的區別?
26、如何解決跨域問題?
27、頁面編碼和被請求的資源編碼如果不一致如何處理？
28、模塊化開發怎麼做？
29、AMD（Moles/Asynchronous-Definition）、CMD（Common Mole
Definition）規范區別？
30、requireJS的核心原理是什麼？（如何動態載入的？如何避免多次載入的？如何緩存的？）
31、讓你自己設計實現一個requireJS，你會怎麼做？
32、談一談你對ECMAScript6的了解？
33、ECMAScript6 怎麼寫class么，為什麼會出現class這種東西?
34、非同步載入的方式有哪些？
35、documen.write和 innerHTML的區別?
36、DOM操作——怎樣添加、移除、移動、復制、創建和查找節點?
37、.call() 和 .apply() 的含義和區別？
38、數組和對象有哪些原生方法，列舉一下？
39、JS 怎麼實現一個類。怎麼實例化這個類
40、JavaScript中的作用域與變數聲明提升？
41、如何編寫高性能的Javascript？
42、那些操作會造成內存泄漏？
43、JQuery的源碼看過嗎？能不能簡單概況一下它的實現原理？
44、jQuery.fn的init方法返回的this指的是什麼對象？為什麼要返回this？
45、jquery中如何將數組轉化為json字元串，然後再轉化回來？
46、jQuery 的屬性拷貝(extend)的實現原理是什麼，如何實現深拷貝？
47、jquery.extend 與 jquery.fn.extend的區別？
48、jQuery 的隊列是如何實現的？隊列可以用在哪些地方？
49、談一下Jquery中的bind(),live(),delegate(),on()的區別？
50、JQuery一個對象可以同時綁定多個事件，這是如何實現的？
51、是否知道自定義事件。jQuery里的fire函數是什麼意思，什麼時候用？
52、jQuery 是通過哪個方法和 Sizzle 選擇器結合的？（jQuery.fn.find()進入Sizzle）
53、針對 jQuery性能的優化方法？
54、Jquery與jQuery UI有啥區別？
55、JQuery的源碼看過嗎？能不能簡單說一下它的實現原理？
56、jquery 中如何將數組轉化為json字元串，然後再轉化回來？
57、jQuery和Zepto的區別？各自的使用場景？
58、針對 jQuery 的優化方法？
59、Zepto的點透問題如何解決？
60、jQueryUI如何自定義組件?
61、需求：實現一個頁面操作不會整頁刷新的網站，並且能在瀏覽器前進、後退時正確響應。給出你的技術實現方案？
62、如何判斷當前腳本運行在瀏覽器還是node環境中？（阿里）
63、移動端最小觸控區域是多大？
64、jQuery 的 slideUp動畫，如果目標元素是被外部事件驅動, 當滑鼠快速地連續觸發外部元素事件, 動畫會滯後的反復執行，該如何處理呢?
65、把 Script 標簽放在頁面的最底部的body封閉之前和封閉之後有什麼區別？瀏覽器會如何解析它們？
66、移動端的點擊事件的有延遲，時間是多久，為什麼會有？怎麼解決這個延時？（click 有 300ms 延遲,為了實現safari的雙擊事件的設計，瀏覽器要知道你是不是要雙擊操作。）
67、知道各種JS框架(Angular, Backbone, Ember, React, Meteor, Knockout…)么? 能講出他們各自的優點和缺點么?
68、Underscore 對哪些 JS 原生對象進行了擴展以及提供了哪些好用的函數方法？
69、解釋JavaScript中的作用域與變數聲明提升？
70、那些操作會造成內存泄漏？
71、JQuery一個對象可以同時綁定多個事件，這是如何實現的？
72、Node.js的適用場景？
(如果會用node)知道route, middleware, cluster, nodemon, pm2, server-side rendering么?
73、解釋一下 Backbone 的 MVC 實現方式？
74、什麼是「前端路由」?什麼時候適合使用「前端路由」? 「前端路由」有哪些優點和缺點?
75、知道什麼是webkit么? 知道怎麼用瀏覽器的各種工具來調試和debug代碼么?
76、如何測試前端代碼么? 知道BDD, TDD, Unit Test么? 知道怎麼測試你的前端工程么(mocha, sinon, jasmin, qUnit..)?
77、前端templating(Mustache, underscore, handlebars)是幹嘛的, 怎麼用?
78、簡述一下 Handlebars 的基本用法？
79、簡述一下 Handlerbars 的對模板的基本處理流程，如何編譯的？如何緩存的？
80、用js實現千位分隔符?(來源：前端農民工，提示：正則+replace)
檢測瀏覽器版本版本有哪些方式？
81、我們給一個dom同時綁定兩個點擊事件，一個用捕獲，一個用冒泡，你來說下會執行幾次事件，然後會先執行冒泡還是捕獲

㈢我的聯通號碼誤標記清除成功後，手機上還存在標記，請問是什麼原因

以江蘇聯通為例：有以下原因：
（1）手機終端不是實時與標記服務後台進行數據同步，存在幾天不等的延時。
（2）部分版本較低的手機終端和應用無法自動與標記服務後台進行數據同步，需要用戶手工更新手機終端操作系統或標記APP應用數據。
（3）部分手機終端需要手工清除緩存數據，即刪除本機於被標記號碼的通話記錄，重啟手機。
（4）標記清除後很快又有新標記產生。

㈣ JVM有哪些垃圾回收演算法

標記-清除，標記-復制，標記-整理

㈤深入理解GC垃圾回收機制

在我們程序運行中會不斷創建新的對象，這些對象會存儲在內存中，如果沒有一套機制來回收這些內存，那麼被佔用的內存會越來越多，可用內存會越來越少，直至內存被消耗完。於是就有了一套垃圾回收機制來做這件維持系統平衡的任務。

1.確保被引用對象的內存不被錯誤的回收
2.回收不再被引用的對象的內存空間

給對象中添加一個引用計數器，每當有一個地方引用它時，計數器值就加1；當引用失效時，計數器值就減1；任何時刻計數器為0的對象就是不可能再被使用的。

優點：引用計數收集器可以很快地執行，交織在程序的運行之中。
缺點：很難處理循環引用，比如上圖中相互引用的兩個對象，計數器不為0，則無法釋放，但是這樣的對象存在是沒有意義的，空占內存了。

引用計數法處理不了的相互引用的問題，那麼就有了可達性分析來解決了這個問題。

從GC Roots作為起點，向下搜索它們引用的對象，可以生成一棵引用樹，樹的節點視為可達對象，反之最終不能與GC Roots有引用關系的視為不可達，不可達對象即為垃圾回收對象。

我自己的理解是，皇室家族每過一段時間，會進行皇室成員排查，從皇室第一代開始往下找血緣關系的後代，如果你跟第一代皇室沒有關系，那麼你就會被剔除皇室家族。

1.虛擬機棧中引用的對象（正在運行的方法使用到的變數、參數等）
2.方法區中類靜態屬性引用的對象（static關鍵字聲明的欄位）
3.方法區中常量引用的對象，(也就是final關鍵字聲明的欄位)
4.本地方法棧中引用的對象（native方法）

1.顯示地賦予某個對象為null，切斷可達性

在main方法中創建objectA、objectB兩個局部變數，而且相互引用。相互引用直接調System.gc()是回收不了的。而將兩者都置為null，切斷相互引用，切斷了可達性，與GCRoots無引用，那麼這兩個對象就會被回收調。

2.將對象的引用指向另一個對象

這里將one的引用也指向了two引用指向的對象，那麼one原本指向的對象就失去了GCRoots引用，這里就判斷該對象可被回收。

3.局部對象的使用

當方法執行完，局部變數object對象會被判定為可回收對象。

4.只有軟、弱、虛引用與之關聯
new出來的對象被強引用了，就需要去掉強引用，改為弱引用。被弱引用之後，需要置空來幹掉強引用，達到隨時可回收的效果。

只被軟引用的對象在內存不足的情況，可能會被GC回收掉。

只被弱引用持有的對象，隨時都可能被GC回收，該對象就為可回收對象。

是不是被判定為了可回收對象，就一定會被回收了呢。其實Ojbect類中還有一個finalize方法。這個方法是對象在被GC回收之前會被觸發的方法。

該方法翻譯過來就是：當垃圾回收確定不再有對該對象的引用時，由垃圾回收器在對象上調用。子類重寫finalize方法以處置系統資源或執行其他清除。說人話就是對象死前會給你一個迴光返照，讓你清醒一下，想干什麼就干什麼，甚至可以把自己救活。我們可以通過重寫finalize方法，來讓對象復活一下。

示例：

執行的結果：

這里我們重寫FinalizeGC類的finalize方法，使用FinalizeGC.instance = this語句，讓對象又有了引用，不再被判定為可回收對象，這里就活了。然後再置空再回收一下，這個對象就死了，沒有再被救活了。所以finalize方法只能被執行一次，沒有再次被救活的機會。

在JDK1.8版本廢棄了永久代，替代的是元空間（MetaSpace），元空間與永久代上類似，都是方法區的實現，他們最大區別是：元空間並不在JVM中，而是使用本地內存。
元空間有注意有兩個參數：

MetaspaceSize ：初始化元空間大小，控制發生GC閾值
MaxMetaspaceSize ：限制元空間大小上限，防止異常佔用過多物理內存
為什麼移除永久代？
移除永久代原因：為融合HotSpot JVM與JRockit VM（新JVM技術）而做出的改變，因為JRockit沒有永久代。
有了元空間就不再會出現永久代OOM問題了！

1.Generational Collection（分代收集）演算法
分代收集演算法是GC垃圾回收演算法的總綱領。現在主流的Java虛擬機的垃圾收集器都採用分代收集演算法。Java 堆區基於分代的概念，分為新生代（Young Generation）和老年代（Tenured Generation），其中新生代再細分為Eden空間、From Survivor空間和To Survivor空間。 (Survivor：倖存者)

分代收集演算法會結合不同的收集演算法來處理不同的空間，因此在學習分代收集演算法之前我們首先要了解Java堆區的空間劃分。Java堆區的空間劃分在Java虛擬機中，各種對象的生命周期會有著較大的差別。因此，應該對不同生命周期的對象採取不同的收集策略，根據生命周期長短將它們分別放到不同的區域，並在不同的區域採用不同的收集演算法，這就是分代的概念。

當執行一次GC Collection時，Eden空間的存活對象會被復制到To Survivor空間，並且之前經過一次GC Collection並在From Survivor空間存活的仍年輕的對象也會復制到To Survivor空間。

對象進入到From和To區之後，對象的GC分代年齡ege的屬性，每經過GC回收存活下來，ege就會+1，當ege達到15了，對象就會晉級到老年代。

2.Mark-Sweep（標記-清除）演算法
標記清除：標記階段的任務是標記出所有需要被回收的對象，清除階段就是回收被標記的對象所佔用的空間。標記-清除演算法主要是運用在Eden區，該區對象很容易被回收掉，回收率很高。

3.Copying（復制）演算法
復制演算法的使用在From區和To區，每次只使用其中的一塊。當這一塊的內存用完了，就將還存活著的對象復制到另外一塊上面，然後再把已使用的內存空間一次清理掉，這樣一來就不容易出現內存碎片的問題。

缺點：可使用內存縮減為一半大小。

那麼復制演算法使可使用內存大小會減半，設計上是怎麼解決這個問題的呢。就是給From和To區劃分盡可能小的區域。經過大數據統計之後，對象在第一次使用過後，絕大多數都會被回收，所以能進入第一次復制演算法的對象只佔10%。那麼設計上，Eden、From、To區的比例是8:1:1，絕大多數對象會分配到Eden區，這樣就解決了復制演算法縮減可用內存帶來的問題。

4.Mark-Compact (標記—整理)演算法
在新生代中可以使用復制演算法，但是在老年代就不能選擇復制演算法了，因為老年代的對象存活率會較高，這樣會有較多的復制操作，導致效率變低。標記—清除演算法可以應用在老年代中，但是它效率不高，在內存回收後容易產生大量內存碎片。因此就出現了一種標記—整理演算法，與標記—清除演算法不同的是，在標記可回收的對象後將所有存活的對象壓縮到內存的一端，使它們緊湊地排列在一起，然後對邊界以外的內存進行回收，回收後，已用和未用的內存都各自一邊。

垃圾收集演算法是內存回收的方法論，那麼垃圾收集器就是內存回收的具體實現：
Serial 收集器（復制演算法): 新生代單線程收集器，標記和清理都是單線程，
優點是簡單高效；
Serial Old 收集器 (標記-整理演算法): 老年代單線程收集器，Serial 收集器
的老年代版本；
ParNew 收集器 (復制演算法): 新生代收並行集器，實際上是 Serial 收集器
的多線程版本，在多核 CPU 環境下有著比 Serial 更好的表現；
CMS(Concurrent Mark Sweep)收集器（標記-清除演算法）：老年代並行
收集器，以獲取最短回收停頓時間為目標的收集器，具有高並發、低停頓
的特點，追求最短 GC 回收停頓時間。

㈥ JVM的垃圾演算法有哪幾種

一、垃圾收集器概述

如上圖所示，垃圾回收演算法一共有7個，3個屬於年輕代、三個屬於年老代，G1屬於橫跨年輕代和年老代的演算法。

JVM會從年輕代和年老代各選出一個演算法進行組合，連線表示哪些演算法可以組合使用

二、各個垃圾收集器說明

1、Serial(年輕代）

年輕代收集器，可以和Serial Old、CMS組合使用
採用復制演算法
使用單線程進行垃圾回收，回收時會導致Stop The World，用戶進程停止
client模式年輕代默認演算法
GC日誌關鍵字：DefNew(Default New Generation)
圖示（Serial+Serial Old)
7、G1
G1收集器由於沒有使用過，所以從網上找了一些教程供大家了解
並行與並發
分代收集
空間整合
可預測的停頓

㈦ sweeping size

標記清除演算法。
標記清除演算法由標記和清除兩階段構成，標記階段是把所有活動對象做上標記，清除階段是清除未被標記的對象。標記階段使用深度優先搜索演算法遍歷所有對象逐個標記（深度優先搜索比廣度優先搜索更能降低內存使用量）。
延遲清楚法縮減因清除操作而導致的mutator最大暫停時間的方法。在標記操作結束後，不一並進行清除操作，而是如其字面意思一樣讓它「延遲」，通過「延遲」來防止mutator長時間暫停。

㈧ java有哪些垃圾回收演算法

常用的垃圾回收演算法有：
(1).引用計數演算法：
給對象中添加一個引用計數器，每當有一個地方引用它時，計數器值就加1；當引用失效時，計數器值就減1；任何時刻計數器都為0的對象就是不再被使用的，垃圾收集器將回收該對象使用的內存。
引用計數演算法實現簡單，效率很高，微軟的COM技術、ActionScript、Python等都使用了引用計數演算法進行內存管理，但是引用計數演算法對於對象之間相互循環引用問題難以解決，因此java並沒有使用引用計數演算法。
(2).根搜索演算法：
通過一系列的名為「GC Root」的對象作為起點，從這些節點向下搜索，搜索所走過的路徑稱為引用鏈(Reference Chain)，當一個對象到GC Root沒有任何引用鏈相連時，則該對象不可達，該對象是不可使用的，垃圾收集器將回收其所佔的內存。
主流的商用程序語言C#、java和Lisp都使用根搜素演算法進行內存管理。
在java語言中，可作為GC Root的對象包括以下幾種對象：
a. java虛擬機棧(棧幀中的本地變數表)中的引用的對象。
b.方法區中的類靜態屬性引用的對象。
c.方法區中的常量引用的對象。
d.本地方法棧中JNI本地方法的引用對象。
java方法區在Sun HotSpot虛擬機中被稱為永久代，很多人認為該部分的內存是不用回收的，java虛擬機規范也沒有對該部分內存的垃圾收集做規定，但是方法區中的廢棄常量和無用的類還是需要回收以保證永久代不會發生內存溢出。
判斷廢棄常量的方法：如果常量池中的某個常量沒有被任何引用所引用，則該常量是廢棄常量。
判斷無用的類：
(1).該類的所有實例都已經被回收，即java堆中不存在該類的實例對象。
(2).載入該類的類載入器已經被回收。
(3).該類所對應的java.lang.Class對象沒有任何地方被引用，無法在任何地方通過反射機制訪問該類的方法。
Java中常用的垃圾收集演算法：
(1).標記-清除演算法：
最基礎的垃圾收集演算法，演算法分為「標記」和「清除」兩個階段：首先標記出所有需要回收的對象，在標記完成之後統一回收掉所有被標記的對象。
標記-清除演算法的缺點有兩個：首先，效率問題，標記和清除效率都不高。其次，標記清除之後會產生大量的不連續的內存碎片，空間碎片太多會導致當程序需要為較大對象分配內存時無法找到足夠的連續內存而不得不提前觸發另一次垃圾收集動作。
(2).復制演算法：
將可用內存按容量分成大小相等的兩塊，每次只使用其中一塊，當這塊內存使用完了，就將還存活的對象復制到另一塊內存上去，然後把使用過的內存空間一次清理掉。這樣使得每次都是對其中一塊內存進行回收，內存分配時不用考慮內存碎片等復雜情況，只需要移動堆頂指針，按順序分配內存即可，實現簡單，運行高效。
復制演算法的缺點顯而易見，可使用的內存降為原來一半。
(3).標記-整理演算法：
標記-整理演算法在標記-清除演算法基礎上做了改進，標記階段是相同的標記出所有需要回收的對象，在標記完成之後不是直接對可回收對象進行清理，而是讓所有存活的對象都向一端移動，在移動過程中清理掉可回收的對象，這個過程叫做整理。
標記-整理演算法相比標記-清除演算法的優點是內存被整理以後不會產生大量不連續內存碎片問題。
復制演算法在對象存活率高的情況下就要執行較多的復制操作，效率將會變低，而在對象存活率高的情況下使用標記-整理演算法效率會大大提高。
(4).分代收集演算法：
根據內存中對象的存活周期不同，將內存劃分為幾塊，java的虛擬機中一般把內存劃分為新生代和年老代，當新創建對象時一般在新生代中分配內存空間，當新生代垃圾收集器回收幾次之後仍然存活的對象會被移動到年老代內存中，當大對象在新生代中無法找到足夠的連續內存時也直接在年老代中創建。

㈨這部是什麼，就老司機解答

你好，捯果自源

8 d d 6 e , C 〇 m

標記/整理演算法與標記/清除演算法非常相似，

它也是分為兩個階段：標記和整理，

標記：它的第一個階段與標記/清除演算法是一模一樣的，均是遍歷GC Roots，然後將存活的對象標記。

整理：移動所有存活的對象，且按照內存地址次序依次排列，然後將末端內存地址以後的內存全部回收。因此，第二階段才稱為整理階段。

㈩常用的內存管理方法有哪幾種

常用的內存管理方法有哪幾種?下面是我給大家收集整理的一些相關方法技巧，希望對大家有幫助!

常用的內存管理方法

傳統的內存整理軟體工作原理大概是：先申請一塊“巨大內存”。因為物理內存幾乎全被內存整理軟體佔用，因此Windows被迫把其他軟體的內存數據轉移到硬碟上的“虛擬內存交換文件”(PageFile)中，完成這一過程之後內存整理軟體就會釋放掉剛剛申請的內存，至此整理過程完成，可用物理內存顯著增加。

大體上都是那麼回事，就是通過輔助空間，重新安排內存內容 ....

但是其中使用的演算法，效率是有很大的區別的～～ <script type="text/javascript"> </script><script type="text/javascript" src=pagead2.googlesyndication/pagead/show_ads.js"> </script>

拓荒時代

國內的程序員大多是在 Java 語言中第一次感受到垃圾收集技術的巨大魅力的，許多人也因此把 Java 和垃圾收集看成了密不可分的整體。但事實上，垃圾收集技術早在 Java 語言問世前 30 多年就已經發展和成熟起來了， Java 語言所做的不過是把這項神奇的技術帶到了廣大程序員身邊而已。

如果一定要為垃圾收集技術找一個孿生兄弟，那麼， Lisp 語言才是當之無愧的人選。 1960 年前後誕生於 MIT 的 Lisp 語言是第一種高度依賴於動態內存分配技術的語言： Lisp 中幾乎所有數據都以“表”的形式出現，而“表”所佔用的空間則是在堆中動態分配得到的。 Lisp 語言先天就具有的動態內存管理特性要求 Lisp 語言的設計者必須解決堆中每一個內存塊的自動釋放問題(否則， Lisp 程序員就必然被程序中不計其數的 free 或 delete 語句淹沒)，這直接導致了垃圾收集技術的誕生和發展——說句題外話，上大學時，一位老師曾告訴我們， Lisp 是對現代軟體開發技術貢獻最大的語言。我當時對這一說法不以為然：布滿了圓括弧，看上去像迷宮一樣的 Lisp 語言怎麼能比 C 語言或 Pascal 語言更偉大呢?不過現在，當我知道垃圾收集技術、數據結構技術、人工智慧技術、並行處理技術、虛擬機技術、元數據技術以及程序員們耳熟能詳的許多技術都起源於 Lisp 語言時，我特別想向那位老師當面道歉，並收回我當時的幼稚想法。

知道了 Lisp 語言與垃圾收集的密切關系，我們就不難理解，為什麼垃圾收集技術的兩位先驅者 J. McCarthy 和 M. L. Minsky 同時也是 Lisp 語言發展史上的重要人物了。 J. McCarthy 是 Lisp 之父，他在發明 Lisp 語言的同時也第一次完整地描述了垃圾收集的演算法和實現方式; M. L. Minsky 則在發展 Lisp 語言的過程中成為了今天好幾種主流垃圾收集演算法的奠基人——和當時不少技術大師的經歷相似， J. McCarthy 和 M. L. Minsky 在許多不同的技術領域里都取得了令人艷羨的成就。也許，在 1960 年代那個軟體開發史上的拓荒時代里，思維敏捷、意志堅定的研究者更容易成為無所不能的西部硬漢吧。

在了解垃圾收集演算法的起源之前，有必要先回顧一下內存分配的主要方式。我們知道，大多數主流的語言或運行環境都支持三種最基本的內存分配方式，它們分別是：

一、靜態分配( Static Allocation )：靜態變數和全局變數的分配形式。我們可以把靜態分配的內存看成是家裡的耐用傢具。通常，它們無需釋放和回收，因為沒人會天天把大衣櫃當作垃圾扔到窗外。

二、自動分配( Automatic Allocation )：在棧中為局部變數分配內存的方法。棧中的內存可以隨著代碼塊退出時的出棧操作被自動釋放。這類似於到家中串門的訪客，天色一晚就要各回各家，除了個別不識時務者以外，我們一般沒必要把客人捆在垃圾袋裡掃地出門。

三、動態分配( Dynamic Allocation )：在堆中動態分配內存空間以存儲數據的方式。堆中的內存塊好像我們日常使用的餐巾紙，用過了就得扔到垃圾箱里，否則屋內就會滿地狼藉。像我這樣的懶人做夢都想有一台家用機器人跟在身邊打掃衛生。在軟體開發中，如果你懶得釋放內存，那麼你也需要一台類似的機器人——這其實就是一個由特定演算法實現的垃圾收集器。

也就是說，下面提到的所有垃圾收集演算法都是在程序運行過程中收集並清理廢舊“餐巾紙”的演算法，它們的操作對象既不是靜態變數，也不是局部變數，而是堆中所有已分配內存塊。

引用計數( Reference Counting )演算法

1960 年以前，人們為胚胎中的 Lisp 語言設計垃圾收集機制時，第一個想到的演算法是引用計數演算法。拿餐巾紙的例子來說，這種演算法的原理大致可以描述為：

午餐時，為了把腦子里突然跳出來的設計靈感記下來，我從餐巾紙袋中抽出一張餐巾紙，打算在上面畫出系統架構的藍圖。按照“餐巾紙使用規約之引用計數版”的要求，畫圖之前，我必須先在餐巾紙的一角寫上計數值 1 ，以表示我在使用這張餐巾紙。這時，如果你也想看看我畫的藍圖，那你就要把餐巾紙上的計數值加 1 ，將它改為 2 ，這表明目前有 2 個人在同時使用這張餐巾紙(當然，我是不會允許你用這張餐巾紙來擦鼻涕的)。你看完後，必須把計數值減 1 ，表明你對該餐巾紙的使用已經結束。同樣，當我將餐巾紙上的內容全部謄寫到筆記本上之後，我也會自覺地把餐巾紙上的計數值減 1 。此時，不出意外的話，這張餐巾紙上的計數值應當是 0 ，它會被垃圾收集器——假設那是一個專門負責打掃衛生的機器人——撿起來扔到垃圾箱里，因為垃圾收集器的惟一使命就是找到所有計數值為 0 的餐巾紙並清理它們。

引用計數演算法的優點和缺陷同樣明顯。這一演算法在執行垃圾收集任務時速度較快，但演算法對程序中每一次內存分配和指針操作提出了額外的要求(增加或減少內存塊的引用計數)。更重要的是，引用計數演算法無法正確釋放循環引用的內存塊，對此， D. Hillis 有一段風趣而精闢的論述：

一天，一個學生走到 Moon 面前說：“我知道如何設計一個更好的垃圾收集器了。我們必須記錄指向每個結點的指針數目。” Moon 耐心地給這位學生講了下面這個故事：“一天，一個學生走到 Moon 面前說：‘我知道如何設計一個更好的垃圾收集器了……’”

D. Hillis 的故事和我們小時候常說的“從前有座山，山上有個廟，廟里有個老和尚”的故事有異曲同工之妙。這說明，單是使用引用計數演算法還不足以解決垃圾收集中的所有問題。正因為如此，引用計數演算法也常常被研究者們排除在狹義的垃圾收集演算法之外。當然，作為一種最簡單、最直觀的解決方案，引用計數演算法本身具有其不可替代的優越性。 1980 年代前後， D. P. Friedman ， D. S. Wise ， H. G. Baker 等人對引用計數演算法進行了數次改進，這些改進使得引用計數演算法及其變種(如延遲計數演算法等)在簡單的環境下，或是在一些綜合了多種演算法的現代垃圾收集系統中仍然可以一展身手。

標記-清除( Mark-Sweep )演算法

第一種實用和完善的垃圾收集演算法是 J. McCarthy 等人在 1960 年提出並成功地應用於 Lisp 語言的標記-清除演算法。仍以餐巾紙為例，標記-清除演算法的執行過程是這樣的：

午餐過程中，餐廳里的所有人都根據自己的需要取用餐巾紙。當垃圾收集機器人想收集廢舊餐巾紙的時候，它會讓所有用餐的人先停下來，然後，依次詢問餐廳里的每一個人：“你正在用餐巾紙嗎?你用的是哪一張餐巾紙?”機器人根據每個人的回答將人們正在使用的餐巾紙畫上記號。詢問過程結束後，機器人在餐廳里尋找所有散落在餐桌上且沒有記號的餐巾紙(這些顯然都是用過的廢舊餐巾紙)，把它們統統扔到垃圾箱里。

正如其名稱所暗示的那樣，標記-清除演算法的執行過程分為“標記”和“清除”兩大階段。這種分步執行的思路奠定了現代垃圾收集演算法的思想基礎。與引用計數演算法不同的是，標記-清除演算法不需要運行環境監測每一次內存分配和指針操作，而只要在“標記”階段中跟蹤每一個指針變數的指向——用類似思路實現的垃圾收集器也常被後人統稱為跟蹤收集器( Tracing Collector )

伴隨著 Lisp 語言的成功，標記-清除演算法也在大多數早期的 Lisp 運行環境中大放異彩。盡管最初版本的標記-清除演算法在今天看來還存在效率不高(標記和清除是兩個相當耗時的過程)等諸多缺陷，但在後面的討論中，我們可以看到，幾乎所有現代垃圾收集演算法都是標記-清除思想的延續，僅此一點， J. McCarthy 等人在垃圾收集技術方面的貢獻就絲毫不亞於他們在 Lisp 語言上的成就了。

復制( Copying )演算法

為了解決標記-清除演算法在垃圾收集效率方面的缺陷， M. L. Minsky 於 1963 年發表了著名的論文“一種使用雙存儲區的 Lisp 語言垃圾收集器( A LISP Garbage Collector Algorithm Using Serial Secondary Storage )”。 M. L. Minsky 在該論文中描述的演算法被人們稱為復制演算法，它也被 M. L. Minsky 本人成功地引入到了 Lisp 語言的一個實現版本中。

復制演算法別出心裁地將堆空間一分為二，並使用簡單的復制操作來完成垃圾收集工作，這個思路相當有趣。借用餐巾紙的比喻，我們可以這樣理解 M. L. Minsky 的復制演算法：

餐廳被垃圾收集機器人分成南區和北區兩個大小完全相同的部分。午餐時，所有人都先在南區用餐(因為空間有限，用餐人數自然也將減少一半)，用餐時可以隨意使用餐巾紙。當垃圾收集機器人認為有必要回收廢舊餐巾紙時，它會要求所有用餐者以最快的速度從南區轉移到北區，同時隨身攜帶自己正在使用的餐巾紙。等所有人都轉移到北區之後，垃圾收集機器人只要簡單地把南區中所有散落的餐巾紙扔進垃圾箱就算完成任務了。下一次垃圾收集的工作過程也大致類似，惟一的不同只是人們的轉移方向變成了從北區到南區。如此循環往復，每次垃圾收集都只需簡單地轉移(也就是復制)一次，垃圾收集速度無與倫比——當然，對於用餐者往返奔波於南北兩區之間的辛勞，垃圾收集機器人是決不會流露出絲毫憐憫的。

M. L. Minsky 的發明絕對算得上一種奇思妙想。分區、復制的思路不僅大幅提高了垃圾收集的效率，而且也將原本繁紛復雜的內存分配演算法變得前所未有地簡明和扼要(既然每次內存回收都是對整個半區的回收，內存分配時也就不用考慮內存碎片等復雜情況，只要移動堆頂指針，按順序分配內存就可以了)，這簡直是個奇跡!不過，任何奇跡的出現都有一定的代價，在垃圾收集技術中，復制演算法提高效率的代價是人為地將可用內存縮小了一半。實話實說，這個代價未免也太高了一些。

無論優缺點如何，復制演算法在實踐中都獲得了可以與標記-清除演算法相比擬的成功。除了 M. L. Minsky 本人在 Lisp 語言中的工作以外，從 1960 年代末到 1970 年代初， R. R. Fenichel 和 J. C. Yochelson 等人也相繼在 Lisp 語言的不同實現中對復制演算法進行了改進， S. Arnborg 更是成功地將復制演算法應用到了 Simula 語言中。

至此，垃圾收集技術的三大傳統演算法——引用計數演算法、標記-清除演算法和復制演算法——都已在 1960 年前後相繼問世，三種演算法各有所長，也都存在致命的缺陷。從 1960 年代後期開始，研究者的主要精力逐漸轉向對這三種傳統演算法進行改進或整合，以揚長避短，適應程序設計語言和運行環境對垃圾收集的效率和實時性所提出的更高要求。

走向成熟

從 1970 年代開始，隨著科學研究和應用實踐的不斷深入，人們逐漸意識到，一個理想的垃圾收集器不應在運行時導致應用程序的暫停，不應額外佔用大量的內存空間和 CPU 資源，而三種傳統的垃圾收集演算法都無法滿足這些要求。人們必須提出更新的演算法或思路，以解決實踐中碰到的諸多難題。當時，研究者的努力目標包括：

第一，提高垃圾收集的效率。使用標記-清除演算法的垃圾收集器在工作時要消耗相當多的 CPU 資源。早期的 Lisp 運行環境收集內存垃圾的時間竟佔到了系統總運行時間的 40% !——垃圾收集效率的低下直接造就了 Lisp 語言在執行速度方面的壞名聲;直到今天，許多人還條件反射似地誤以為所有 Lisp 程序都奇慢無比。

第二，減少垃圾收集時的內存佔用。這一問題主要出現在復制演算法中。盡管復制演算法在效率上獲得了質的突破，但犧牲一半內存空間的代價仍然是巨大的。在計算機發展的早期，在內存價格以 KB 計算的日子裡，浪費客戶的一半內存空間簡直就是在變相敲詐或攔路打劫。

第三，尋找實時的垃圾收集演算法。無論執行效率如何，三種傳統的垃圾收集演算法在執行垃圾收集任務時都必須打斷程序的當前工作。這種因垃圾收集而造成的延時是許多程序，特別是執行關鍵任務的程序沒有辦法容忍的。如何對傳統演算法進行改進，以便實現一種在後台悄悄執行，不影響——或至少看上去不影響——當前進程的實時垃圾收集器，這顯然是一件更具挑戰性的工作。

研究者們探尋未知領域的決心和研究工作的進展速度同樣令人驚奇：在 1970 年代到 1980 年代的短短十幾年中，一大批在實用系統中表現優異的新演算法和新思路脫穎而出。正是因為有了這些日趨成熟的垃圾收集演算法，今天的我們才能在 Java 或 .NET 提供的運行環境中隨心所欲地分配內存塊，而不必擔心空間釋放時的風險。

標記-整理( Mark-Compact )演算法

標記-整理演算法是標記-清除演算法和復制演算法的有機結合。把標記-清除演算法在內存佔用上的優點和復制演算法在執行效率上的特長綜合起來，這是所有人都希望看到的結果。不過，兩種垃圾收集演算法的整合並不像 1 加 1 等於 2 那樣簡單，我們必須引入一些全新的思路。 1970 年前後， G. L. Steele ， C. J. Cheney 和 D. S. Wise 等研究者陸續找到了正確的方向，標記-整理演算法的輪廓也逐漸清晰了起來：

在我們熟悉的餐廳里，這一次，垃圾收集機器人不再把餐廳分成兩個南北區域了。需要執行垃圾收集任務時，機器人先執行標記-清除演算法的第一個步驟，為所有使用中的餐巾紙畫好標記，然後，機器人命令所有就餐者帶上有標記的餐巾紙向餐廳的南面集中，同時把沒有標記的廢舊餐巾紙扔向餐廳北面。這樣一來，機器人只消站在餐廳北面，懷抱垃圾箱，迎接撲面而來的廢舊餐巾紙就行了。

實驗表明，標記-整理演算法的總體執行效率高於標記-清除演算法，又不像復制演算法那樣需要犧牲一半的存儲空間，這顯然是一種非常理想的結果。在許多現代的垃圾收集器中，人們都使用了標記-整理演算法或其改進版本。

增量收集( Incremental Collecting )演算法

對實時垃圾收集演算法的研究直接導致了增量收集演算法的誕生。

最初，人們關於實時垃圾收集的想法是這樣的：為了進行實時的垃圾收集，可以設計一個多進程的運行環境，比如用一個進程執行垃圾收集工作，另一個進程執行程序代碼。這樣一來，垃圾收集工作看上去就彷彿是在後台悄悄完成的，不會打斷程序代碼的運行。

在收集餐巾紙的例子中，這一思路可以被理解為：垃圾收集機器人在人們用餐的同時尋找廢棄的餐巾紙並將它們扔到垃圾箱里。這個看似簡單的思路會在設計和實現時碰上進程間沖突的難題。比如說，如果垃圾收集進程包括標記和清除兩個工作階段，那麼，垃圾收集器在第一階段中辛辛苦苦標記出的結果很可能被另一個進程中的內存操作代碼修改得面目全非，以至於第二階段的工作沒有辦法開展。

M. L. Minsky 和 D. E. Knuth 對實時垃圾收集過程中的技術難點進行了早期的研究， G. L. Steele 於 1975 年發表了題為“多進程整理的垃圾收集( Multiprocessing compactifying garbage collection )”的論文，描述了一種被後人稱為“ Minsky-Knuth-Steele 演算法”的實時垃圾收集演算法。 E. W. Dijkstra ， L. Lamport ， R. R. Fenichel 和 J. C. Yochelson 等人也相繼在此領域做出了各自的貢獻。 1978 年， H. G. Baker 發表了“串列計算機上的實時表處理技術( List Processing in Real Time on a Serial Computer )”一文，系統闡述了多進程環境下用於垃圾收集的增量收集演算法。

增量收集演算法的基礎仍是傳統的標記-清除和復制演算法。增量收集演算法通過對進程間沖突的妥善處理，允許垃圾收集進程以分階段的方式完成標記、清理或復制工作。詳細分析各種增量收集演算法的內部機理是一件相當繁瑣的事情，在這里，讀者們需要了解的僅僅是： H. G. Baker 等人的努力已經將實時垃圾收集的夢想變成了現實，我們再也不用為垃圾收集打斷程序的運行而煩惱了。

分代收集( Generational Collecting )演算法

和大多數軟體開發技術一樣，統計學原理總能在技術發展的過程中起到強力催化劑的作用。 1980 年前後，善於在研究中使用統計分析知識的技術人員發現，大多數內存塊的生存周期都比較短，垃圾收集器應當把更多的精力放在檢查和清理新分配的內存塊上。這個發現對於垃圾收集技術的價值可以用餐巾紙的例子概括如下：

如果垃圾收集機器人足夠聰明，事先摸清了餐廳里每個人在用餐時使用餐巾紙的習慣——比如有些人喜歡在用餐前後各用掉一張餐巾紙，有的人喜歡自始至終攥著一張餐巾紙不放，有的人則每打一個噴嚏就用去一張餐巾紙——機器人就可以制定出更完善的餐巾紙回收計劃，並總是在人們剛扔掉餐巾紙沒多久就把垃圾撿走。這種基於統計學原理的做法當然可以讓餐廳的整潔度成倍提高。

D. E. Knuth ， T. Knight ， G. Sussman 和 R. Stallman 等人對內存垃圾的分類處理做了最早的研究。 1983 年， H. Lieberman 和 C. Hewitt 發表了題為“基於對象壽命的一種實時垃圾收集器( A real-time garbage collector based on the lifetimes of objects )”的論文。這篇著名的論文標志著分代收集演算法的正式誕生。此後，在 H. G. Baker ， R. L. Hudson ， J. E. B. Moss 等人的共同努力下，分代收集演算法逐漸成為了垃圾收集領域里的主流技術。

分代收集演算法通常將堆中的內存塊按壽命分為兩類，年老的和年輕的。垃圾收集器使用不同的收集演算法或收集策略，分別處理這兩類內存塊，並特別地把主要工作時間花在處理年輕的內存塊上。分代收集演算法使垃圾收集器在有限的資源條件下，可以更為有效地工作——這種效率上的提高在今天的 Java 虛擬機中得到了最好的證明。

應用浪潮

Lisp 是垃圾收集技術的第一個受益者，但顯然不是最後一個。在 Lisp 語言之後，許許多多傳統的、現代的、後現代的語言已經把垃圾收集技術拉入了自己的懷抱。隨便舉幾個例子吧：誕生於 1964 年的 Simula 語言， 1969 年的 Smalltalk 語言， 1970 年的 Prolog 語言， 1973 年的 ML 語言， 1975 年的 Scheme 語言， 1983 年的 Mola-3 語言， 1986 年的 Eiffel 語言， 1987 年的 Haskell 語言……它們都先後使用了自動垃圾收集技術。當然，每一種語言使用的垃圾收集演算法可能不盡相同，大多數語言和運行環境甚至同時使用了多種垃圾收集演算法。但無論怎樣，這些實例都說明，垃圾收集技術從誕生的那一天起就不是一種曲高和寡的“學院派”技術。

對於我們熟悉的 C 和 C++ 語言，垃圾收集技術一樣可以發揮巨大的功效。正如我們在學校中就已經知道的那樣， C 和 C++ 語言本身並沒有提供垃圾收集機制，但這並不妨礙我們在程序中使用具有垃圾收集功能的函數庫或類庫。例如，早在 1988 年， H. J. Boehm 和 A. J. Demers 就成功地實現了一種使用保守垃圾收集演算法( Conservative GC Algorithmic )的函數庫。我們可以在 C 語言或 C++ 語言中使用該函數庫完成自動垃圾收集功能，必要時，甚至還可以讓傳統的 C/C++ 代碼與使用自動垃圾收集功能的 C/C++ 代碼在一個程序里協同工作。

1995 年誕生的 Java 語言在一夜之間將垃圾收集技術變成了軟體開發領域里最為流行的技術之一。從某種角度說，我們很難分清究竟是 Java 從垃圾收集中受益，還是垃圾收集技術本身借 Java 的普及而揚名。值得注意的是，不同版本的 Java 虛擬機使用的垃圾收集機制並不完全相同， Java 虛擬機其實也經過了一個從簡單到復雜的發展過程。在 Java 虛擬機的 1.4.1 版中，人們可以體驗到的垃圾收集演算法就包括分代收集、復制收集、增量收集、標記-整理、並行復制( Parallel Copying )、並行清除( Parallel Scavenging )、並發( Concurrent )收集等許多種， Java 程序運行速度的不斷提升在很大程度上應該歸功於垃圾收集技術的發展與完善。

盡管歷史上已經有許多包含垃圾收集技術的應用平台和操作系統出現，但 Microsoft .NET 卻是第一種真正實用化的、包含了垃圾收集機制的通用語言運行環境。事實上， .NET 平台上的所有語言，包括 C# 、 Visual Basic .NET 、 Visual C++ .NET 、 J# 等等，都可以通過幾乎完全相同的方式使用 .NET 平台提供的垃圾收集機制。我們似乎可以斷言， .NET 是垃圾收集技術在應用領域里的一次重大變革，它使垃圾收集技術從一種單純的技術變成了應用環境乃至操作系統中的一種內在文化。這種變革對未來軟體開發技術的影響力也許要遠遠超過 .NET 平台本身的商業價值。

大勢所趨

今天，致力於垃圾收集技術研究的人們仍在不懈努力，他們的研究方向包括分布式系統的垃圾收集、復雜事務環境下的垃圾收集、資料庫等特定系統的垃圾收集等等。

但在程序員中間，仍有不少人對垃圾收集技術不屑一顧，他們寧願相信自己逐行編寫的 free 或 delete 命令，也不願把垃圾收集的重任交給那些在他們看來既蠢又笨的垃圾收集器。

我個人認為，垃圾收集技術的普及是大勢所趨，這就像生活會越來越好一樣毋庸置疑。今天的程序員也許會因為垃圾收集器要佔用一定的 CPU 資源而對其望而卻步，但二十多年前的程序員還曾因為高級語言速度太慢而堅持用機器語言寫程序呢!在硬體速度日新月異的今天，我們是要吝惜那一點兒時間損耗而踟躇不前，還是該堅定不移地站在代碼和運行環境的凈化劑——垃圾收集的一邊呢?

導航:首頁 > 源碼編譯 > 標記清楚演算法是同步的嗎

標記清楚演算法是同步的嗎

8 d d 6 e , C 〇 m

與標記清楚演算法是同步的嗎相關的資料