原理：檔案資料庫sqlite，同一時刻允許多個程序/執行緒讀，但同一時刻只允許一個執行緒寫。在操行寫操作時，資料庫檔案被瑣定，此時任何其他讀/寫操作都被阻塞，如果阻塞超過5秒鐘(預設是5秒，能過重新編譯sqlite可以修改超時時間)，就報"database is locked"錯誤。

所以，在操作sqlite時，應該即時關閉連線；開啟連線後，儘量減少非常費時的操作。

1. 方法

在頁面中用到了ViewPager控制元件，ViewPager中的內容分別是兩個ListView，兩個ListView的資料都來自本地資料庫（先從網路下載資料，然後更新本地資料庫），在實際的使用過程中發現會出現SQLiteDatabaseLockedException: database is locked的問題。

經網上搜索資料，發現是讀寫資料庫時存在的同步問題，所以採用單例+同步鎖的方法，並且在每次資料庫操作後都關閉資料庫，經測試後發現沒有在出現上述問題。

以下是兩個主類

DBHelper.java（這個類用來管理資料庫）

public class DBHelper extends SQLiteOpenHelper {

	private final String TAG = this.getClass().getSimpleName();
	
	public final static String DATABASE_NAME = "test.db";
	public final static String TABLE = "table";
	public final static int DATABASE_VERSION = 2;

	public DBHelper(Context context) {
		super(context, DATABASE_NAME, null, DATABASE_VERSION);
	}

	private static DBHelper mInstance;

	public synchronized static DBHelper getInstance(Context context) {
		if (mInstance == null) {
			mInstance = new DBHelper(context);
		}
		return mInstance;
	};

	@Override
	public void onCreate(SQLiteDatabase db) {
		try {
			db.execSQL("CREATE TABLE IF NOT EXISTS " + TABLE
					+ "(id INTEGER PRIMARY KEY ,data BLOB)");
		} catch (SQLiteException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {	
		
		// 刪除原來的資料表
		db.execSQL("DROP TABLE IF EXISTS " + TABLE);
		// 重新建立
		onCreate(db);
	}

	public static byte[] objectToBytes(Object obj) throws Exception {

		ByteArrayOutputStream out = new ByteArrayOutputStream();
		ObjectOutputStream sOut = new ObjectOutputStream(out);
		sOut.writeObject(obj);
		sOut.flush();
		byte[] bytes = out.toByteArray();
		return bytes;
	}

	public static Object bytesToObject(byte[] bytes) throws Exception {

		ByteArrayInputStream in = new ByteArrayInputStream(bytes);
		ObjectInputStream sIn = new ObjectInputStream(in);
		return sIn.readObject();
	}
}
 

DBStudentManager類（這裡可以定義自己的管理類）

public class DBStudentManager {

	private DBHelper helper;
	private SQLiteDatabase db;

	public DBStudentManager(Context context) {
		helper = DBHelper.getInstance(context);
		db = helper.getWritableDatabase();
	}

	// 插入
	private void insert(Student student) {

		synchronized (helper) {
			// 看資料庫是否關閉
			if (!db.isOpen()) {
				db = helper.getWritableDatabase();
			}
			// 開始事務
			db.beginTransaction();
			try {
				db.execSQL(
						"INSERT INTO " + DBHelper.TABLE + " VALUES(?,?)",
						new Object[] { student.mID,
								DBHelper.objectToBytes(student) });
				db.setTransactionSuccessful(); // 設定事務成功完成
			} catch (SQLException e) {
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				db.endTransaction();
				db.close();
			}
		}
	}

	// 更新
	private void update(Student student) {

		synchronized (helper) {
			if (!db.isOpen()) {
				db = helper.getWritableDatabase();
			}
			db.beginTransaction();
			try {
				db.execSQL("UPDATE " + DBHelper.TABLE
						+ "SET data = ? WHERE id = ?",
						new Object[] { DBHelper.objectToBytes(student),
								student.mID });
				db.setTransactionSuccessful(); // 設定事務成功完成
			} catch (SQLException e) {
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				db.endTransaction();
				db.close();
			}
		}
	}

	// 同步
	public void synchronous(List<Student> students) {
		if (students == null) {
			return;
		}
		for (Student student : students) {
			if (query(student.mID) == null) {
				insert(student);
			} else {
				update(student);
			}
		}
	}

	// 刪除指定資料
	public void delete(String id) {

		synchronized (helper) {
			if (!db.isOpen()) {
				db = helper.getWritableDatabase();
			}
			db.beginTransaction();
			try {
				db.execSQL("DELETE FROM " + DBHelper.TABLE + " WHERE id = ? ",
						new String[] { id });
				db.setTransactionSuccessful();
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				db.endTransaction();
				db.close();
			}
		}
	}

	// 刪除所有資料
	public void delete() {

		synchronized (helper) {
			if (!db.isOpen()) {
				db = helper.getWritableDatabase();
			}
			db.beginTransaction();
			try {
				db.execSQL("DELETE * FROM " + DBHelper.TABLE);
				db.setTransactionSuccessful();
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				db.endTransaction();
				db.close();
			}
		}
	}

	// 查詢所有的Students
	public List<Student> query() {

		List<Student> students = new ArrayList<Student>();
		synchronized (helper) {
			if (!db.isOpen()) {
				db = helper.getWritableDatabase();
			}
			Cursor c = queryTheCursor();
			Student student = null;
			try {
				while (c.moveToNext()) {

					byte[] bytes = c.getBlob((c.getColumnIndex("data")));
					student = (Student) DBHelper.bytesToObject(bytes);
					students.add(student);
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				c.close();
			}
		}
		return students;
	}

	// 查詢指定ID的Student
	public Student query(String id) {

		Student student = null;
		synchronized (helper) {
			if (!db.isOpen()) {
				helper.getWritableDatabase();
			}
			Cursor c = queryTheCursor(id);
			try {
				while (c.moveToNext()) {

					byte[] bytes = c.getBlob((c.getColumnIndex("data")));
					student = (Student) DBHelper.bytesToObject(bytes);
					break;
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				c.close();
			}
		}
		return student;
	}

	// 獲取遊標
	public Cursor queryTheCursor(String id) {
		Cursor c = db.rawQuery("SELECT FROM " + DBHelper.TABLE
				+ " WHERE id = ?", new String[] { id });
		return c;
	}

	// 獲取遊標
	public Cursor queryTheCursor() {
		Cursor c = db.rawQuery("SELECT * FROM " + DBHelper.TABLE);
		return c;
	}

	class Student {

		String mID;
		String mName;
		int mAge;
	}
}
 

 2. 方法

遇到這個問題，有幾種可能，我在下面詳細的列出來，方便大家在遇到的時候檢視

· 多執行緒訪問造成的資料庫鎖定。

public static synchronized DBConnection getConnection(String connectionName) throws Exception { String pathFile = getPath() + connectionName;// 轉換目錄data下 return new DBConnection(SQLiteDatabase.openDatabase(pathFile, null, SQLiteDatabase.OPEN_READWRITE)); }

3. 方法

如果多執行緒同時讀寫（這裡的指不同的執行緒用使用的是不同的Helper例項），後面的就會遇到android.database.sqlite.SQLiteException: database is locked這樣的異常。
對於這樣的問題，解決的辦法就是keep single sqlite connection，保持單個SqliteOpenHelper例項，同時對所有資料庫操作的方法新增synchronized關鍵字。
完美解決sqlite的 database locked 或者是 error 5: database locked 問題