Android——SharedPreferences

1. 场景

首先我们来看看,SharedPreferences在什么场景比较适用:

  • SharedPreferences是一种轻量级的存储,数据会写在本地的一个xml文件中,以键值对的形式存在,如果程序卸载,此文件也跟着卸载
  • 以Map形式存放简单的配置参数
  • 可以保存的数据类型有:int、boolean、float、long、String、StringSet。
  • 保存位置:data/data/程序包名/share_prefs
  • 主要用途:
    • 1.保存应用的设置 例如:设置静音,下次进入还是静音
    • 2.判断是否是第一次登陆

性能:

  • ShredPreferences是单例对象,第一次打开后,之后获取都无需创建,速度很快。
  • 当第一次获取数据后,数据会被加载到一个缓存的Map中,之后的读取都会非常快。
  • 当由于是XML<->Map的存储方式,所以,数据越大,操作越慢,get、commit、apply、remove、clear都会受影响,所以尽量把数据按功能拆分成若干份。

2. SharedPreferences的使用

  • SharedPreferences对象本身只能获取数据而不支持存储和修改,存储修改是通过SharedPreferences.edit()获取的内部接口Editor对象实现
  • 使用Preference来存取数据,用到了SharedPreferences接口和SharedPreferences的一个内部接口SharedPreferences.Editor,这两个接口在android.content包中

2.1 存储数据:

  • 使用Activity类的getSharedPreferences方法获得SharedPreferences对象;
  • 使用SharedPreferences接口的edit获得SharedPreferences.Editor对象;
  • 通过SharedPreferences.Editor接口的putXXX方法保存key-value对;
  • 通过过SharedPreferences.Editor接口的commit方法保存key-value对。

2.2 读取数据:

  • 使用Activity类的getSharedPreferences方法获得SharedPreferences对象;
  • 通过SharedPreferences对象的getXXX方法获取数据

2.3 方法:

获取SharedPreferences对象:

//根据name查找SharedPreferences,若已经存在则获取,若不存在则创建一个新的
public abstract SharedPreferences getSharedPreferences (String name, int mode)

参数:
name:命名
mode:模式,包括

  • MODE_PRIVATE(只能被自己的应用程序访问)
  • MODE_WORLD_READABLE(除了自己访问外还可以被其它应该程序读取)
  • MODE_WORLD_WRITEABLE(除了自己访问外还可以被其它应该程序读取和写入)

若该Activity只需要创建一个SharedPreferences对象的时候,可以使用getPreferences方法,不需要为SharedPreferences对象命名,只要传入参数mode即可

public SharedPreferences getPreferences (int mode)

获取Editor对象(由SharedPreferences对象调用):

abstract SharedPreferences.Editor edit()

写入数据(由Editor对象调用):

参数:
key:指定数据对应的key
value:指定的值

//写入boolean类型的数据
abstract SharedPreferences.Editor   putBoolean(String key, boolean value)
//写入float类型的数据
abstract SharedPreferences.Editor   putFloat(String key, float value)
//写入int类型的数据
abstract SharedPreferences.Editor   putInt(String key, int value)
//写入long类型的数据
abstract SharedPreferences.Editor   putLong(String key, long value)
//写入String类型的数据
abstract SharedPreferences.Editor   putString(String key, String value)
//写入Set<String>类型的数据
abstract SharedPreferences.Editor   putStringSet(String key, Set<String> values)

移除指定key的数据(由Editor对象调用):

abstract SharedPreferences.Editor   remove(String key)

清空数据(由Editor对象调用):

abstract SharedPreferences.Editor   clear()

提交数据(由Editor对象调用):

abstract boolean    commit()

读取数据(由SharedPreferences对象调用):

参数
key:指定数据的key
defValue:当读取不到指定的数据时,使用的默认值defValue

//读取所有数据
abstract Map<String, ?> getAll()
//读取的数据为boolean类型
abstract boolean    getBoolean(String key, boolean defValue)
//读取的数据为float类型
abstract float  getFloat(String key, float defValue)
//读取的数据为int类型
abstract int    getInt(String key, int defValue)
//读取的数据为long类型
abstract long   getLong(String key, long defValue)
//读取的数据为String类型
abstract String getString(String key, String defValue)
//读取的数据为Set<String>类型
abstract Set<String>    getStringSet(String key, Set<String> defValues)

2.4 例子

 1)写入数据:
     //步骤1:创建一个SharedPreferences对象
     SharedPreferences sharedPreferences= getSharedPreferences("data",Context.MODE_PRIVATE);
     //步骤2: 实例化SharedPreferences.Editor对象
     SharedPreferences.Editor editor = sharedPreferences.edit();
     //步骤3:将获取过来的值放入文件
     editor.putString("name",Tom);
     editor.putInt("age", 28);
     editor.putBoolean("marrid",false);
     //步骤4:提交               
     editor.commit();


 2)读取数据:
     SharedPreferences sharedPreferences= getSharedPreferences("data", Context .MODE_PRIVATE);
     String userId=sharedPreferences.getString("name","");

3)删除指定数据
     editor.remove("name");
     editor.commit();


4)清空数据
     editor.clear();
     editor.commit();

3 Tips

tip 1:

是否在Acitivty里执行?

在Acitivty中执行的:

getSharedPreferences (String name, int mode)
getPreferences (int mode) 
MODE_PRIVATE

不在Activity中:

context.getSharedPreferences (String name, int mode)
context.getPreferences (int mode)
Conetxt.MODE_PRIVATE 

tip 2:

  • 所保存的SharedPreferences数据将一直存在,除非被覆盖、移除、清空或文件被删除。
  • SharedPreferences保存的数据会随着应用的卸载而被删除

tip 3:

同时执行这两句代码的时候,第一行代码所写的内容会被第二行代码取代。

editor.putInt("age", 20);
//覆盖key为age的数据,得到的结果:age = 32
editor.putInt("age", 32);

editor.putString("age", "20");
//覆盖key为age的数据,得到的结果:age = 32 (int类型)
editor.putInt("age", 32);

tip 4:

执行以下代码会出现异常。
(指定key所保存的类型和读取时的类型不同)

editor.putInt("age", 32);//保存为int类型
String age = userInfo.getString("age", "null");//读取时为String类型,出现异常

tip 5:

在这些动作之后,记得commit

editor.putInt("age", 20);//写入操作
editor.remove("age");   //移除操作
editor.clear();     //清空操作
editor.commit();//记得commit

4. SharedPreferences的问题

其实SharedPreferences作为一种轻量级的数据存储方式,使用起来也非常方便,以键值对的形式存储在本地,初始化 SharedPreference 的时候,会将整个文件内容加载内存中,因此会带来以下问题:

  • getXXX()获取值的形式有可能会导致主线程阻塞
  • SharedPreferences不能保证类型安全, 加载的数据会一直留在内存中,浪费内存
  • apply()方法虽然是异步的,可能会发生 ANR
  • apply() 方法无法获取到操作成功或者失败的结果

4.1 为什么getXXX()方法会导致主线程阻塞

因为getXXX()都是同步的,在主线程调用 get 方法时,同步方法内调用了 wait() 方法,会一直等待 getSharedPreferences() 方法开启的线程读取完数据才能继续往下执行,如果数据量读取的小,并没有什么影响,如果读取的文件较大会导致主线程阻塞

具体大家可以查看haredPreferences源码:
frameworks/base/core/java/android/app/SharedPreferencesImpl.java

4.2 SharedPreferences不能保证类型安全,并且一直会留在内存中

 	val key = "DataStore"
    val sp = getSharedPreferences("文件名", Context.MODE_PRIVATE) 
    sp.edit { putInt(key, 0) } // 使用 Int 类型的数据覆盖相同的 key
    sp.getString(key, ""); // 使用相同的 key 读取 Sting 类型的数据

使用 Int 类型的数据覆盖掉相同的 key,然后使用相同的 key 读取 Sting 类型的数就会造成ClassCastException异常
而通过 getSharedPreferences() 方法加载的数据,最后会将数据存储在静态的成员变量中。

4.3 apply()方法是异步的,可能会发生ANR

异步的提交为什么会发生ANR呢?

apply 方法中:

@Override
        public void apply() {
            final long startTime = System.currentTimeMillis();
            //将修改先写入内存 
            final MemoryCommitResult mcr = commitToMemory(); 
            //这里只是创建了一个 Runnable ,并不是一个线程
            final Runnable awaitCommit = new Runnable() {
                    @Override
                    public void run() {
                        try {
                           //注意这里会进行等待也就是 需要 MemoryCommitResult 的 setDiskWriteResult 方法执行后
                           //才能返回 

                            mcr.writtenToDiskLatch.await();
                        } catch (InterruptedException ignored) {
                        }

                        if (DEBUG && mcr.wasWritten) {
                            Log.d(TAG, mFile.getName() + ":" + mcr.memoryStateGeneration
                                    + " applied after " + (System.currentTimeMillis() - startTime)
                                    + " ms");
                        }
                    }
                };

            //添加到队列中
            QueuedWork.addFinisher(awaitCommit);

            //这里也只创建一个 Runnable 
            Runnable postWriteRunnable = new Runnable() {
                    @Override
                    public void run() {
                    //这里执行了上面的 awaitCommit 的 run 方法
                    //不是 start 
                    //并将队列中的 awaitCommit 移除
                        awaitCommit.run();
                        QueuedWork.removeFinisher(awaitCommit);
                    }
                };
            //添加到队列中
            SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);

            // Okay to notify the listeners before it's hit disk
            // because the listeners should always get the same
            // SharedPreferences instance back, which has the
            // changes reflected in memory.
            notifyListeners(mcr);
        }
private void enqueueDiskWrite(final MemoryCommitResult mcr,
                                  final Runnable postWriteRunnable) {
        final boolean isFromSyncCommit = (postWriteRunnable == null);
        //创建一个 Runnable ,同样也没有 start 
        final Runnable writeToDiskRunnable = new Runnable() {
                @Override
                public void run() {
                    synchronized (mWritingToDiskLock) {
                        writeToFile(mcr, isFromSyncCommit);
                    }
                    synchronized (mLock) {
                        mDiskWritesInFlight--;
                    }
                    if (postWriteRunnable != null) {
                        postWriteRunnable.run();
                    }
                }
            };
         //如果是 commit 则执行这里并返回
        // Typical #commit() path with fewer allocations, doing a write on
        // the current thread.
        if (isFromSyncCommit) {
            boolean wasEmpty = false;
            synchronized (mLock) {
                wasEmpty = mDiskWritesInFlight == 1;
            }
            if (wasEmpty) {
                writeToDiskRunnable.run();
                return;
            }
        }
         //如果是 apply 就执行这里
        QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);
    }

在 QueuedWork.java 中:

public static void queue(Runnable work, boolean shouldDelay) {
       //getHandler 获取的是一个 handlerThread 的hanlder ,也就是一个子线程
        Handler handler = getHandler();

        synchronized (sLock) {
            sWork.add(work);

            if (shouldDelay && sCanDelay) {
            //发送一个消息 MSG_RUN 到 handler 所在线程,也就是 handlerThread 子线程中去
                handler.sendEmptyMessageDelayed(QueuedWorkHandler.MSG_RUN, DELAY);
            } else {
                handler.sendEmptyMessage(QueuedWorkHandler.MSG_RUN);
            }
        }
    }

    private static Handler getHandler() {
        synchronized (sLock) {
            if (sHandler == null) {
            //创建一个 handlerThread ,并执行 start 方法
            //这就是 apply 写到磁盘的线程
                HandlerThread handlerThread = new HandlerThread("queued-work-looper",
                        Process.THREAD_PRIORITY_FOREGROUND);
                handlerThread.start();

                sHandler = new QueuedWorkHandler(handlerThread.getLooper());
            }
            return sHandler;
        }
    }
// Handler 的处理
private static class QueuedWorkHandler extends Handler {
        static final int MSG_RUN = 1;

        QueuedWorkHandler(Looper looper) {
            super(looper);
        }

        public void handleMessage(Message msg) {
            if (msg.what == MSG_RUN) {
                processPendingWork();
            }
        }
    }

    private static void processPendingWork() {
        long startTime = 0;


        synchronized (sProcessingWork) {
            LinkedList<Runnable> work;

            synchronized (sLock) {
             //复制前面的工作队列 
                work = (LinkedList<Runnable>) sWork.clone();
                sWork.clear();

                // Remove all msg-s as all work will be processed now
                getHandler().removeMessages(QueuedWorkHandler.MSG_RUN);
            }
            //一个一个执行 run 方法,
            if (work.size() > 0) {
                for (Runnable w : work) {
                    w.run();
                }


                }
            }
        }
    }

在上面的方法中注意到 对每个 apply 都会创建一个相应的 awaitCommit,并添加到 QueuedWork 的一个队列中,但是在 QueuedWork 注意到有这样一个方法 waitToFinish

/**
     * Trigger queued work to be processed immediately. The queued work is processed on a separate
     * thread asynchronous. While doing that run and process all finishers on this thread. The
     * finishers can be implemented in a way to check weather the queued work is finished.
     *
     * Is called from the Activity base class's onPause(), after BroadcastReceiver's onReceive,
     * after Service command handling, etc. (so async work is never lost)
     */
    public static void waitToFinish() {}

这个方法会在 Activity 暂停时或者 BroadcastReceiver 的 onReceive 方法调用后或者 service 的命令处理后被调用,并且调用这个方法的目的是为了确保异步任务被及时完成。
可以看到 waitToFinish 都是在 ActivityThread 中,也就是主线程调用的

public static void waitToFinish() {

        boolean hadMessages = false;

        Handler handler = getHandler();

        synchronized (sLock) {
            if (handler.hasMessages(QueuedWorkHandler.MSG_RUN)) {
                // Delayed work will be processed at processPendingWork() below
                handler.removeMessages(QueuedWorkHandler.MSG_RUN);

            }

            // We should not delay any work as this might delay the finishers
            sCanDelay = false;
        }

        StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
        try {
        //这个方法就会执行 所有的 Runnable 的run 返回
        //这个时候 processPendingWork 是执行在主线程中

            processPendingWork();
        } finally {
            StrictMode.setThreadPolicy(oldPolicy);
        }

        try {
            while (true) {
                Runnable finisher;

                synchronized (sLock) {
                    finisher = sFinishers.poll();
                }

                if (finisher == null) {
                    break;
                }

                finisher.run();
            }
        } finally {
            sCanDelay = true;
        }

       ...
    }

这种设计是为了保证 SP 可靠的、保证写入完成的存储机制。

总结一下就是:

  • apply 没有返回值
  • apply 是在主线程将修改数据提交到内存, 然后再子线程(HandleThread)提交到磁盘
  • apply 会将 Runnble 添加到 QueueWork 中,如果主线程 Activity 暂停时或者 BroadcastReceiver 的 onReceive 方法调用后或者 service 的- 命令处理,就会在主线程执行 提交到硬盘的方法,这个过程就会造成主线程 ANR

5 Google推荐使用DataStore 替换 SharedPreferences

Jetpack DataStore 是一种数据存储解决方案,允许您使用协议缓冲区存储键值对或类型化对象。DataStore 使用 Kotlin 协程和 Flow 以异步、一致的事务方式存储数据。

如果您当前在使用 SharedPreferences 存储数据,请考虑迁移到 DataStore。

DataStore | Android开发者平台

  • 2
    点赞
  • 6
    收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:书香水墨 设计师:CSDN官方博客 返回首页
评论 1

打赏作者

Yawn__

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值