แนวคิดและการใช้งาน Jetpack Compose
Android มีการรองรับ SQLite ในตัว ซึ่งเป็นฐานข้อมูล SQL ที่มีประสิทธิภาพ ทำตามแนวทางปฏิบัติแนะนำเหล่านี้เพื่อเพิ่มประสิทธิภาพของแอป เพื่อให้มั่นใจว่าแอปจะยังคงทำงานได้อย่างรวดเร็วและคาดการณ์ได้เมื่อข้อมูลเพิ่มขึ้น การใช้แนวทางปฏิบัติแนะนำเหล่านี้ยังช่วยลดโอกาสที่จะพบปัญหาด้านประสิทธิภาพที่จำลองและแก้ปัญหาได้ยากด้วย
โปรดทำตามหลักการด้านประสิทธิภาพต่อไปนี้เพื่อให้ทำงานได้เร็วขึ้น
อ่านแถวและคอลัมน์น้อยลง: เพิ่มประสิทธิภาพการค้นหาเพื่อดึงเฉพาะข้อมูลที่จำเป็น ลดปริมาณข้อมูลที่อ่านจากฐานข้อมูล เนื่องจาก การดึงข้อมูลมากเกินไปอาจส่งผลต่อประสิทธิภาพ
พุชงานไปยังเครื่องมือ SQLite: ทำการคำนวณ การกรอง และการจัดเรียงภายในคำสั่ง SQL การใช้เครื่องมือค้นหาของ SQLite จะช่วยปรับปรุงประสิทธิภาพได้อย่างมาก
แก้ไขสคีมาฐานข้อมูล: ออกแบบสคีมาฐานข้อมูลเพื่อช่วยให้ SQLite สร้างแผนการค้นหาและการแสดงข้อมูลที่มีประสิทธิภาพ จัดทำดัชนีตารางอย่างเหมาะสมและเพิ่มประสิทธิภาพโครงสร้างตารางเพื่อปรับปรุงประสิทธิภาพ
นอกจากนี้ คุณยังใช้เครื่องมือแก้ปัญหาที่มีอยู่เพื่อวัดประสิทธิภาพของฐานข้อมูล SQLite เพื่อช่วยระบุส่วนที่ต้องเพิ่มประสิทธิภาพได้ด้วย
เราขอแนะนำให้ใช้ไลบรารี Jetpack Room
กำหนดค่าฐานข้อมูลเพื่อประสิทธิภาพ
ทำตามขั้นตอนในส่วนนี้เพื่อกำหนดค่าฐานข้อมูลให้มีประสิทธิภาพสูงสุดใน SQLite
ผ่อนคลายโหมดการซิงค์ข้อมูล
SQLite มีตัวเลือกในการควบคุมโหมดซิงโครนัส ในโหมด FULL ทุกๆ การคอมมิตจะออก fsync เพื่อช่วยให้มั่นใจว่าข้อมูลจะไปถึงดิสก์ ซึ่งจะช่วยปรับปรุงความคงทนของข้อมูล แต่จะทำให้การคอมมิตช้าลง เมื่อใช้ WAL โหมด NORMAL จะไม่ซิงค์ในทุกคอมมิตและยังคงปกป้องฐานข้อมูลจากความเสียหาย
เมื่อคุณเปิดใช้ WAL ผ่านเฟรมเวิร์ก Android จะใช้โหมดซิงโครนัส WAL เริ่มต้นของอุปกรณ์ ซึ่งก็คือ NORMAL ใน AOSP สำหรับ Android 9 ขึ้นไป
ผู้ผลิตอุปกรณ์สามารถเปลี่ยนค่าเริ่มต้นนี้ได้ และฐานข้อมูลที่ไม่ได้ใช้ WAL จะมีค่าเริ่มต้นเป็น FULL หากต้องการตรวจสอบว่าฐานข้อมูลใช้ NORMAL ให้ตั้งค่าเมื่อคุณเปิดฐานข้อมูล ดังนี้
Kotlin
// When opening the database
val params = SQLiteDatabase.OpenParams.Builder()
.addOpenFlags(SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING)
// SYNC_MODE_NORMAL is available in API level 33 and higher.
// On API levels 28 to 32, pass "NORMAL" instead.
.setSynchronousMode(SQLiteDatabase.SYNC_MODE_NORMAL)
.build()
// With SQLiteOpenHelper, call setOpenParams(params) in your constructor.
// Or: after having opened the database
db.execSQL("PRAGMA synchronous = NORMAL")
Java
// When opening the database
SQLiteDatabase.OpenParams params = new SQLiteDatabase.OpenParams.Builder()
.addOpenFlags(SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING)
// SYNC_MODE_NORMAL is available in API level 33 and higher.
// On API levels 28 to 32, pass "NORMAL" instead.
.setSynchronousMode(SQLiteDatabase.SYNC_MODE_NORMAL)
.build();
// With SQLiteOpenHelper, call setOpenParams(params) in your constructor.
// Or: after having opened the database
db.execSQL("PRAGMA synchronous = NORMAL");
ในการตั้งค่านี้ ระบบจะแสดงผลการคอมมิตก่อนที่จะจัดเก็บข้อมูลในดิสก์ หากอุปกรณ์ปิดเครื่อง เช่น ไฟดับหรือเคอร์เนลแพนิก ข้อมูลที่คอมมิตไว้อาจสูญหาย อย่างไรก็ตาม เนื่องจากมีการบันทึก ฐานข้อมูลของคุณจึงไม่เสียหาย
หากมีเพียงแอปของคุณที่ขัดข้อง ข้อมูลจะยังคงเข้าถึงดิสก์ได้ สําหรับแอปส่วนใหญ่ การตั้งค่านี้จะช่วยปรับปรุงประสิทธิภาพโดยไม่มีค่าใช้จ่ายที่สำคัญ
ปรับปรุงประสิทธิภาพการค้นหา
ทำตามแนวทางปฏิบัติแนะนำต่อไปนี้เพื่อปรับปรุงประสิทธิภาพการค้นหาใน SQLite โดยลดเวลาในการตอบสนองและเพิ่มประสิทธิภาพการประมวลผลให้สูงสุด
อ่านเฉพาะแถวที่ต้องการ
ตัวกรองช่วยให้คุณจำกัดผลการค้นหาให้แคบลงได้โดยระบุเกณฑ์บางอย่าง เช่น ช่วงวันที่ สถานที่ หรือชื่อ ขีดจำกัดช่วยให้คุณควบคุมจำนวนผลลัพธ์ที่เห็นได้ ดังนี้
Kotlin
db.rawQuery("""
SELECT name
FROM Customers
LIMIT 10;
""".trimIndent(),
null
).use { cursor ->
while (cursor.moveToNext()) {
// Process cursor data
}
}
Java
try (Cursor cursor = db.rawQuery("""
SELECT name
FROM Customers
LIMIT 10;
""", null)) {
while (cursor.moveToNext()) {
// Process cursor data
}
}
อ่านเฉพาะคอลัมน์ที่ต้องการ
หลีกเลี่ยงการเลือกคอลัมน์ที่ไม่จำเป็น ซึ่งอาจทำให้การค้นหาช้าลงและสิ้นเปลืองทรัพยากร แต่ให้เลือกเฉพาะคอลัมน์ที่ใช้เท่านั้น
ในตัวอย่างต่อไปนี้ คุณเลือก id, name และ phone
Kotlin
// This is not the most efficient way of doing this.
// See the following example for a better approach.
db.rawQuery(
"""
SELECT id, name, phone
FROM customers;
""".trimIndent(),
null
).use { cursor ->
while (cursor.moveToNext()) {
val name = cursor.getString(1)
// Further processing
}
}
Java
// This is not the most efficient way of doing this.
// See the following example for a better approach.
try (Cursor cursor = db.rawQuery("""
SELECT id, name, phone
FROM customers;
""", null)) {
while (cursor.moveToNext()) {
String name = cursor.getString(1);
// Further processing
}
}
อย่างไรก็ตาม คุณต้องมีคอลัมน์ name เท่านั้น
Kotlin
db.rawQuery("""
SELECT name
FROM Customers;
""".trimIndent(),
null
).use { cursor ->
while (cursor.moveToNext()) {
val name = cursor.getString(0)
// Further processing
}
}
Java
try (Cursor cursor = db.rawQuery("""
SELECT name
FROM Customers;
""", null)) {
while (cursor.moveToNext()) {
String name = cursor.getString(0);
// Further processing
}
}
กำหนดพารามิเตอร์ให้คำค้นหา
สตริงคำค้นหาอาจมีพารามิเตอร์ที่ทราบเฉพาะที่รันไทม์ เช่น
Kotlin
fun getNameById(id: Long): String? {
db.rawQuery(
"SELECT name FROM customers WHERE id=$id", null
).use { cursor ->
return if (cursor.moveToFirst()) {
cursor.getString(0)
} else {
null
}
}
}
Java
@Nullable
public String getNameById(long id) {
try (Cursor cursor = db.rawQuery(
"SELECT name FROM customers WHERE id=" + id, null)) {
if (cursor.moveToFirst()) {
return cursor.getString(0);
} else {
return null;
}
}
}
ในโค้ดก่อนหน้า ทุกการค้นหาจะสร้างสตริงที่แตกต่างกัน จึงไม่ได้รับประโยชน์จากแคชคำสั่ง การเรียกแต่ละครั้งต้องใช้ SQLite เพื่อคอมไพล์ก่อนจึงจะดำเนินการได้ แต่คุณสามารถแทนที่อาร์กิวเมนต์ id ด้วยพารามิเตอร์และเชื่อมโยงค่ากับ selectionArgs แทนได้ ดังนี้
Kotlin
fun getNameById(id: Long): String? {
db.rawQuery(
"""
SELECT name
FROM customers
WHERE id=?
""".trimIndent(), arrayOf(id.toString())
).use { cursor ->
return if (cursor.moveToFirst()) {
cursor.getString(0)
} else {
null
}
}
}
Java
@Nullable
public String getNameById(long id) {
try (Cursor cursor = db.rawQuery("""
SELECT name
FROM customers
WHERE id=?
""", new String[] {String.valueOf(id)})) {
if (cursor.moveToFirst()) {
return cursor.getString(0);
} else {
return null;
}
}
}
ตอนนี้คุณสามารถคอมไพล์การค้นหาเพียงครั้งเดียวและแคชไว้ได้ ระบบจะนำการค้นหาที่คอมไพล์แล้วกลับมาใช้ซ้ำระหว่างการเรียกใช้ getNameById(long) ที่แตกต่างกัน
ใช้ DISTINCT สำหรับค่าที่ไม่ซ้ำกัน
การใช้คีย์เวิร์ด DISTINCT จะช่วยปรับปรุงประสิทธิภาพการค้นหาได้โดยการลดจำนวนข้อมูลที่ต้องประมวลผล เช่น หากต้องการแสดงเฉพาะค่าที่ไม่ซ้ำกันจากคอลัมน์ ให้ใช้ DISTINCT:
Kotlin
db.rawQuery("""
SELECT DISTINCT name
FROM Customers;
""".trimIndent(),
null
).use { cursor ->
while (cursor.moveToNext()) {
// Only iterate over distinct names in Kotlin
// Process distinct name
}
}
Java
try (Cursor cursor = db.rawQuery("""
SELECT DISTINCT name
FROM Customers;
""", null)) {
while (cursor.moveToNext()) {
// Only iterate over distinct names in Java
// Process distinct name
}
}
ใช้ฟังก์ชันรวมข้อมูลเมื่อเป็นไปได้
ใช้ฟังก์ชันรวมข้อมูลสำหรับผลลัพธ์รวมโดยไม่มีข้อมูลแถว ตัวอย่างเช่น โค้ดต่อไปนี้จะตรวจสอบว่ามีแถวที่ตรงกันอย่างน้อย 1 แถวหรือไม่
Kotlin
// This is not the most efficient way of doing this.
// See the following example for a better approach.
db.rawQuery("""
SELECT id, name
FROM Customers
WHERE city = 'Paris';
""".trimIndent(),
null
).use { cursor ->
if (cursor.moveToFirst()) {
// At least one customer from Paris
// Handle found
} else {
// No customers from Paris
// Handle not found
}
Java
// This is not the most efficient way of doing this.
// See the following example for a better approach.
try (Cursor cursor = db.rawQuery("""
SELECT id, name
FROM Customers
WHERE city = 'Paris';
""", null)) {
if (cursor.moveToFirst()) {
// At least one customer from Paris
// Handle found
} else {
// No customers from Paris
// Handle not found
}
}
หากต้องการดึงข้อมูลเฉพาะแถวแรก คุณสามารถใช้ EXISTS() เพื่อแสดงผล 0 หากไม่มีแถวที่ตรงกัน และ 1 หากมีแถวที่ตรงกันอย่างน้อย 1 แถว
Kotlin
db.rawQuery("""
SELECT EXISTS (
SELECT null
FROM Customers
WHERE city = 'Paris';
);
""".trimIndent(),
null
).use { cursor ->
if (cursor.moveToFirst() && cursor.getInt(0) == 1) {
// At least one customer from Paris
// Handle found
} else {
// No customers from Paris
// Handle not found
}
}
Java
try (Cursor cursor = db.rawQuery("""
SELECT EXISTS (
SELECT null
FROM Customers
WHERE city = 'Paris'
);
""", null)) {
if (cursor.moveToFirst() && cursor.getInt(0) == 1) {
// At least one customer from Paris
// Handle found
} else {
// No customers from Paris
// Handle not found
}
}
ใช้ฟังก์ชันรวมข้อมูล SQLite ในโค้ดของแอป ดังนี้
COUNT: นับจำนวนแถวในคอลัมน์SUM: เพิ่มค่าตัวเลขทั้งหมดในคอลัมน์MINหรือMAX: กำหนดค่าต่ำสุดหรือสูงสุด ใช้ได้กับคอลัมน์ตัวเลข ประเภทDATEและประเภทข้อความAVG: ค้นหาค่าตัวเลขเฉลี่ยGROUP_CONCAT: เชื่อมโยงสตริงกับตัวคั่นที่ไม่บังคับ
ใช้ COUNT() แทน Cursor.getCount()
ในตัวอย่างต่อไปนี้ ฟังก์ชัน Cursor.getCount() จะอ่านแถวทั้งหมดจากฐานข้อมูลและแสดงผลค่าแถวทั้งหมด
Kotlin
// This is not the most efficient way of doing this.
// See the following example for a better approach.
db.rawQuery("""
SELECT id
FROM Customers;
""".trimIndent(),
null
).use { cursor ->
val count = cursor.getCount()
// Use count
}
Java
// This is not the most efficient way of doing this.
// See the following example for a better approach.
try (Cursor cursor = db.rawQuery("""
SELECT id
FROM Customers;
""", null)) {
int count = cursor.getCount();
// Use count
}
อย่างไรก็ตาม เมื่อใช้ COUNT() ฐานข้อมูลจะแสดงผลเฉพาะจำนวนเท่านั้น
Kotlin
db.rawQuery("""
SELECT COUNT(*)
FROM Customers;
""".trimIndent(),
null
).use { cursor ->
cursor.moveToFirst()
val count = cursor.getInt(0)
// Use count
}
Java
try (Cursor cursor = db.rawQuery("""
SELECT COUNT(*)
FROM Customers;
""", null)) {
cursor.moveToFirst();
int count = cursor.getInt(0);
// Use count
}
การค้นหา Nest แทนโค้ด
SQL สามารถประกอบได้และรองรับการค้นหาย่อย การรวม และข้อจำกัดของคีย์นอก คุณสามารถใช้ผลลัพธ์ของคำค้นหาหนึ่งในอีกคำค้นหาหนึ่งได้โดยไม่ต้องผ่านโค้ดของแอป ซึ่งจะช่วยลดความจำเป็นในการคัดลอกข้อมูลจาก SQLite และช่วยให้เครื่องมือฐานข้อมูลเพิ่มประสิทธิภาพการค้นหาได้
ในตัวอย่างต่อไปนี้ คุณสามารถเรียกใช้การค้นหาเพื่อดูว่าเมืองใดมีลูกค้ามากที่สุด จากนั้นใช้ผลลัพธ์ในการค้นหาอื่นเพื่อค้นหาลูกค้าทั้งหมดจากเมืองนั้น
Kotlin
// This is not the most efficient way of doing this.
// See the following example for a better approach.
db.rawQuery("""
SELECT city
FROM Customers
GROUP BY city
ORDER BY COUNT(*) DESC
LIMIT 1;
""".trimIndent(),
null
).use { cursor ->
if (cursor.moveToFirst()) {
val topCity = cursor.getString(0)
db.rawQuery("""
SELECT name, city
FROM Customers
WHERE city = ?;
""".trimIndent(),
arrayOf(topCity)).use { innerCursor ->
while (innerCursor.moveToNext()) {
// Process inner cursor data
}
}
}
}
Java
// This is not the most efficient way of doing this.
// See the following example for a better approach.
try (Cursor cursor = db.rawQuery("""
SELECT city
FROM Customers
GROUP BY city
ORDER BY COUNT(*) DESC
LIMIT 1;
""", null)) {
if (cursor.moveToFirst()) {
String topCity = cursor.getString(0);
try (Cursor innerCursor = db.rawQuery("""
SELECT name, city
FROM Customers
WHERE city = ?;
""", new String[] {topCity})) {
while (innerCursor.moveToNext()) {
// Process inner cursor data
}
}
}
}
หากต้องการได้ผลลัพธ์โดยใช้เวลาเพียงครึ่งหนึ่งของตัวอย่างก่อนหน้านี้ ให้ใช้การค้นหา SQL รายการเดียวที่มีคำสั่งที่ซ้อนกัน ดังนี้
Kotlin
db.rawQuery("""
SELECT name, city
FROM Customers
WHERE city IN (
SELECT city
FROM Customers
GROUP BY city
ORDER BY COUNT (*) DESC
LIMIT 1;
);
""".trimIndent(),
null
).use { cursor ->
if (cursor.moveToNext()) {
// Process cursor data
}
}
Java
try (Cursor cursor = db.rawQuery("""
SELECT name, city
FROM Customers
WHERE city IN (
SELECT city
FROM Customers
GROUP BY city
ORDER BY COUNT(*) DESC
LIMIT 1
);
""", null)) {
while(cursor.moveToNext()) {
// Process cursor data
}
}
ตรวจสอบความไม่ซ้ำกันใน SQL
หากต้องไม่แทรกแถวเว้นแต่ค่าคอลัมน์หนึ่งๆ จะไม่ซ้ำกันในตาราง การบังคับใช้ความไม่ซ้ำกันนั้นเป็นข้อจำกัดของคอลัมน์อาจมีประสิทธิภาพมากกว่า
ในตัวอย่างต่อไปนี้ ระบบจะเรียกใช้การค้นหาหนึ่งรายการเพื่อตรวจสอบแถวที่จะแทรก และอีกรายการหนึ่งเพื่อแทรกจริง
Kotlin
// This is not the most efficient way of doing this.
// See the following example for a better approach.
db.rawQuery(
"""
SELECT EXISTS (
SELECT null
FROM customers
WHERE username = ?
);
""".trimIndent(),
arrayOf(customer.username)
).use { cursor ->
if (cursor.moveToFirst() && cursor.getInt(0) == 1) {
throw AddCustomerException(customer)
}
}
db.execSQL(
"INSERT INTO customers VALUES (?, ?, ?)",
arrayOf(
customer.id.toString(),
customer.name,
customer.username
)
)
Java
// This is not the most efficient way of doing this.
// See the following example for a better approach.
try (Cursor cursor = db.rawQuery("""
SELECT EXISTS (
SELECT null
FROM customers
WHERE username = ?
);
""", new String[] { customer.username })) {
if (cursor.moveToFirst() && cursor.getInt(0) == 1) {
throw new AddCustomerException(customer);
}
}
db.execSQL(
"INSERT INTO customers VALUES (?, ?, ?)",
new String[] {
String.valueOf(customer.id),
customer.name,
customer.username,
});
แทนที่จะตรวจสอบข้อจำกัดที่ไม่ซ้ำกันใน Kotlin หรือ Java คุณสามารถตรวจสอบใน SQL เมื่อกำหนดตารางได้ ดังนี้
CREATE TABLE Customers(
id INTEGER PRIMARY KEY,
name TEXT,
username TEXT UNIQUE
);
SQLite จะทำสิ่งเดียวกันดังนี้
CREATE TABLE Customers(...);
CREATE UNIQUE INDEX CustomersUsername ON Customers(username);
ตอนนี้คุณสามารถแทรกแถวและให้ SQLite ตรวจสอบข้อจำกัดได้แล้ว
Kotlin
try {
db.execSQL(
"INSERT INTO Customers VALUES (?, ?, ?)",
arrayOf(customer.id.toString(), customer.name, customer.username)
)
} catch(e: SQLiteConstraintException) {
throw AddCustomerException(customer, e)
}
Java
try {
db.execSQL(
"INSERT INTO Customers VALUES (?, ?, ?)",
new String[] {
String.valueOf(customer.id),
customer.name,
customer.username,
});
} catch (SQLiteConstraintException e) {
throw new AddCustomerException(customer, e);
}
SQLite รองรับดัชนีที่ไม่ซ้ำกันซึ่งมีหลายคอลัมน์ ดังนี้
CREATE TABLE table(...);
CREATE UNIQUE INDEX unique_table ON table(column1, column2, ...);
SQLite ตรวจสอบข้อจำกัดได้เร็วกว่าและมีค่าใช้จ่ายในการดำเนินการน้อยกว่าโค้ด Kotlin หรือ Java แนวทางปฏิบัติแนะนำคือใช้ SQLite แทนโค้ดแอป
รวมการแทรกหลายรายการไว้ในธุรกรรมเดียว
ธุรกรรมจะคอมมิตการดำเนินการหลายรายการ ซึ่งไม่เพียงแต่ช่วยปรับปรุงประสิทธิภาพเท่านั้น แต่ยังช่วยปรับปรุงความถูกต้องด้วย คุณสามารถแทรกแบบเป็นกลุ่มเพื่อปรับปรุงความสอดคล้องของข้อมูลและเร่งประสิทธิภาพได้ ดังนี้
Kotlin
db.beginTransaction()
try {
customers.forEach { customer ->
db.execSQL(
"INSERT INTO Customers VALUES (?, ?, ?)",
arrayOf(customer.id.toString(), customer.name, "customerValue")
)
}
db.setTransactionSuccessful()
} finally {
db.endTransaction()
}
Java
db.beginTransaction();
try {
for (Customer customer : customers) {
db.execSQL(
"INSERT INTO Customers VALUES (?, ?, ?)",
new String[] {
String.valueOf(customer.id),
customer.name,
"customerValue"
});
}
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
เก็บงานที่ไม่ใช่ฐานข้อมูลไว้นอกธุรกรรม อย่าเก็บธุรกรรมการเขียนแบบเปิดไว้ใน I/O ของไฟล์ที่บล็อก เช่น File.delete, คำขอเครือข่าย, การสื่อสารระหว่างโปรเซส เช่น การเรียกหรือการออกอากาศ ContentResolver หรือการรับล็อก ดังนี้
- การเขียนฐานข้อมูลพร้อมกันจะบล็อกจนกว่าธุรกรรมจะสิ้นสุด และหากไม่มี WAL การอ่านก็จะบล็อกด้วย
- การรับการล็อกแอปในระหว่าง
beginTransactionและendTransactionมีความเสี่ยงที่จะเกิดการหยุดชะงักหากเทรดอื่นมีการล็อกนั้นขณะรอการเชื่อมต่อฐานข้อมูล - การย้อนกลับธุรกรรมที่ล้มเหลวจะไม่ยกเลิกผลข้างเคียงภายนอก เช่น ไฟล์ที่ถูกลบ และการออกอากาศที่ส่งก่อนที่
endTransactionจะคอมมิตจะปลุกตัวรับสัญญาณก่อนที่การเปลี่ยนแปลงของคุณจะปรากฏ
เตรียมอินพุตภายนอกก่อนเรียกใช้ beginTransaction, เรียกใช้เฉพาะการดำเนินการ SQLite ระหว่าง beginTransaction และ endTransaction และบันทึกเส้นทางไฟล์หรือเพย์โหลดในหน่วยความจำเพื่อเรียกใช้การล้างข้อมูลหรือส่งการออกอากาศหลังจากคอมมิต endTransaction
หากฐานข้อมูลอ้างอิงไฟล์ที่เปลี่ยนแปลงไม่ได้ ให้จัดเก็บไฟล์เหล่านั้นไว้ในไดเรกทอรีระดับบนเดียว และสร้าง เขียน และซิงค์ไฟล์แต่ละไฟล์ภายใต้ชื่อที่ไม่ซ้ำกันก่อนเริ่มธุรกรรม เนื่องจากชื่อไฟล์ไม่ซ้ำกันและฐานข้อมูลเป็นแหล่งข้อมูลที่ถูกต้องสำหรับไฟล์ที่ใช้งานอยู่ ให้ข้ามขั้นตอนการเปลี่ยนชื่อแบบอะตอมมิก หากต้องการล้างไฟล์ที่เหลืออยู่จากธุรกรรมที่ย้อนกลับหรือแถวที่ถูกแทนที่ ให้กำหนดเวลางาน WorkManager เป็นระยะๆ ในตัวดำเนินการเขียนตามลำดับเดียวกัน (หรือภายใต้การล็อกที่ชัดเจนเดียวกัน) ซึ่งจะจัดลำดับการเขียนฐานข้อมูลและการสร้างไฟล์ เพื่อให้การล้างข้อมูลค้นหาแถวที่ใช้งานอยู่และลบไฟล์ที่ไม่ได้อ้างอิงโดยไม่แย่งกับตัวเขียนที่กำลังทำงานอยู่
แนะนำสำหรับคุณ
- หมายเหตุ: ข้อความลิงก์จะแสดงเมื่อ JavaScript ปิดอยู่
- เรียกใช้การเปรียบเทียบในการรวมอย่างต่อเนื่อง
- เฟรมที่ค้าง
- สร้างและวัด Baseline Profile โดยไม่ต้องใช้ Macrobenchmark