Android实现多进程并发控制的两种方案

风晓得

一、问题背景

当一个App中存在多个进程时例如存在 主进程，辅进程两个进程，两个进程都会去向A文件中写入数据。但是我们业务中希望每次仅允许有一个进程向A文件写入内容。即当主进程写入时，辅进程要等待主进程写完之后才可以写入，防止出现并发修改导致数据异常的问题。
在实际的场景上，例如在我们的项目中未使用MMKV之前，KV存储是自行实现的多进程并发的SP。

二、实现方案


1、方案1：仅一个进程负责写

将所有的写入操作调整到同一个进程中，这样就相当于规避了多进程并发问题。
我们可以通过提供一个ContantProvider或者Service来是实现这个功能。
以下是使用ContentProvider的方式：

FileProvider

1. public class FileProvider extends ContentProvider {
   
2.     private static final String AUTHORITY = "com.example.fileprovider";
   
3.     private static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/file");
   
4. 
   
5.     // 文件锁，确保单进程写入
   
6.     private static final Object fileLock = new Object();
   
7. 
   
8.     @Override
   
9.     public boolean onCreate() {
   
10.         return true;
    
11.     }
    
12. 
    
13.     @Override
    
14.     public Cursor query(Uri uri, String[] projection,
    
15.         String selection, String[] selectionArgs, String sortOrder) {
    
16.         return null; // 不提供查询功能
    
17.     }
    
18. 
    
19.     @Override
    
20.     public String getType(Uri uri) {
    
21.         return null;
    
22.     }
    
23. 
    
24.     @Override
    
25.     public Uri insert(Uri uri, ContentValues values) {
    
26.         return null; // 不提供插入功能
    
27.     }
    
28. 
    
29.     @Override
    
30.     public int delete(Uri uri, String selection, String[] selectionArgs) {
    
31.         return 0; // 不提供删除功能
    
32.     }
    
33. 
    
34.     @Override
    
35.     public int update(Uri uri, ContentValues values,
    
36.         String selection, String[] selectionArgs) {
    
37.         return 0; // 不提供更新功能
    
38.     }
    
39. 
    
40.     // 自定义方法：写入文件
    
41.     @Override
    
42.     public Bundle call(String method, String arg, Bundle extras) {
    
43.         if ("writeToFile".equals(method)) {
    
44.             String content = extras.getString("content");
    
45.             synchronized (fileLock) {
    
46.                 writeToFile(content);
    
47.             }
    
48.             Bundle result = new Bundle();
    
49.             result.putBoolean("success", true);
    
50.             return result;
    
51.         }
    
52.         return super.call(method, arg, extras);
    
53.     }
    
54. 
    
55.     // 实际写入文件的逻辑
    
56.     private void writeToFile(String content) {
    
57.         File file = new File(getContext().getFilesDir(), "A.txt");
    
58.         try (FileOutputStream fos = new FileOutputStream(file, true)) {
    
59.             fos.write(content.getBytes());
    
60.         } catch (IOException e) {
    
61.             e.printStackTrace();
    
62.         }
    
63.     }
    
64. }

复制代码

注册

1. <provider
   
2.     android:name=".FileProvider"
   
3.     android:authorities="com.example.fileprovider"
   
4.     android:exported="true" />

复制代码

写入逻辑

1.     private void writeToFileViaProvider(String content) {
   
2.         Uri uri = Uri.parse("content://com.example.fileprovider/file");
   
3.         ContentResolver resolver = getContentResolver();
   
4.         
   
5.         Bundle extras = new Bundle();
   
6.         extras.putString("content", content);
   
7.         
   
8.         try {
   
9.             Bundle result = resolver.call(uri, "writeToFile", null, extras);
   
10.             if (result != null && result.getBoolean("success")) {
    
11.                 Log.d("FileProvider", "Write successful");
    
12.             }
    
13.         } catch (Exception e) {
    
14.             Log.e("FileProvider", "Failed to write file", e);
    
15.         }
    
16.     }

复制代码

使用Service + Binder的方式，代码比较简单，这里就不写了。

2、方案2：通过文件锁的方式

文件锁主要是利用FileChannel、FileLock来控制多进程并发。

关于 Channel

Channel 经常翻译为通道，类似 IO 中的流，用于读取和写入。不用像BIO那样，读数据和写数据需要不同的数据通道。

1. public interface Channel extends Closeable {
   
2. 
   
3.     /**
   
4.      * Tells whether or not this channel is open.
   
5.      *
   
6.      * @return <tt>true</tt> if, and only if, this channel is open
   
7.      */
   
8.     public boolean isOpen();
   
9. 
   
10.     /**
    
11.      * Closes this channel.
    
12.      */
    
13.     public void close() throws IOException;
    
14. 
    
15. }

复制代码

我们常用的Channel有：

• FileChannel：文件通道，用于文件的读和写。
  
• DatagramChannel：用于UDP连接的接收和发送。
  
• SocketChannel：把它理解为TCP连接通道，简单理解就是TCP客户端。
  
• ServerSocketChannel：TCP对应的服务端，用于监听某个端口进来的请求。
  

FileChannel

FileChannel 是 Java NIO (New I/O) 中的一个类，用于对文件进行高效的读写操作。它提供了比传统

1. FileInputStream

复制代码

和

1. FileOutputStream

复制代码

更灵活和高效的文件操作方式。
所有的NIO操作始于通道，通道是数据来源或数据写入的目的地。其与 Buffer 打交道，读操作的时候将 Channel 中的数据填充到 Buffer 中，而写操作时将 Buffer 中的数据写入到 Channel 中。
FileChannel的获取方式：
通过FileInputStream/FileOutputStream

1. // 通过 FileInputStream/FileOutputStream (只读或只写)
   
2. FileInputStream fis = new FileInputStream("file.txt");
   
3. FileChannel readChannel = fis.getChannel();
   
4. 
   
5. FileOutputStream fos = new FileOutputStream("file.txt");
   
6. FileChannel writeChannel = fos.getChannel();

复制代码

通过RandomAccessFile

1. // 通过 RandomAccessFile
   
2. RandomAccessFile raf = new RandomAccessFile("file.txt", "rw");
   
3. FileChannel channel = raf.getChannel();

复制代码

通过FileChannel.open()

1. FileChannel channel = FileChannel.open(Paths.get("file.txt"), StandardOpenOption.READ);

复制代码

在我们示例代码中选择了使用

1. FileOutputStream

复制代码

来获取FileChannel。

FileLock

1. FileLock

复制代码

表示文件或文件区域的锁，用于控制多个进程或线程对同一文件的并发访问。
锁的类型

• 共享锁 (Shared Lock) ：多个进程可同时持有，用于读操作
  
• 排他锁 (Exclusive Lock) ：一次只能由一个进程持有，用于写操作
  

通过文件锁的方式控制多进程并发的 示例代码：

1. public class FileWriter {
   
2. 
   
3.     private static final String FILE_PATH = "/path/to/your/file.txt";
   
4. 
   
5.     public void writeToFile(String content) {
   
6.         File file = new File(FILE_PATH);
   
7.         try {
   
8.             FileOutputStream fos = new FileOutputStream(file, true);
   
9.             FileChannel channel = fos.getChannel())
   
10.             // 获取独占锁
    
11.             FileLock lock = channel.lock();
    
12.             try {
    
13.                 // 写入文件
    
14.                 fos.write(content.getBytes());
    
15.             } finally {
    
16.                 // 释放锁
    
17.                 lock.release();
    
18.             }
    
19.         } catch (IOException e) {
    
20.             e.printStackTrace();
    
21.         }
    
22.     }
    
23. }

复制代码

三、总结

以上简单介绍了一下两种控制多进程并发的方案。
其中使用ContentProvider或者Service的方式将所有的操作控制在同一个进程中的方案逻辑清晰，但是代码量比较多。尤其是使用Service的方式，虽然上面我们每个给出示例代码，但是可以想象没新增一个进程都需要写相关的代码，写起来就比较啰嗦了。
而ContentProvicer的方式，系统中也有很多相关的实现方案，例如更新媒体文件，更新联系人数据等。
使用文件锁的方式对于仅熟悉Android不熟悉Java的同学不容易想到，所以本篇也同时简单介绍了一下FileChannel以及FileLock。
到此这篇关于Android实现多进程并发控制的两种方案的文章就介绍到这了,更多相关Android多进程并发控制内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

蓬以

顶顶更健康！！！

无为307

感谢楼主，顶。