React Native中Realm应全局实例化还是每次调用Realm.open()？

Great question—this is such a common point of confusion when working with Realm in React Native, so let’s break it down clearly without the jargon.

First, Let’s Demystify Realm.open() #

You’re right that the official docs don’t explicitly mention caching, but Realm does automatically cache instances created with Realm.open(). If you call Realm.open() multiple times with the exact same configuration (schema, path, etc.), it won’t spin up a brand new instance every time—it’ll return the already opened one. So efficiency isn’t a concern here.

The bigger reason to prefer Realm.open() is that it’s asynchronous. Opening a Realm (especially the first time, when it needs to create database files or initialize schemas) involves disk I/O, which can block the main thread if done synchronously. Using the async method ensures this work happens in the background, preventing UI freezes or jank—critical for a smooth user experience. It also gives you proper error handling for edge cases like corrupted database files or invalid schemas.

What About new Realm() for Global Instances? #

Creating a global instance with new Realm() works technically, but it’s risky for a few key reasons:

• Synchronous blocking: If you call new Realm() early in your app’s startup (before the database is fully initialized), it can block the main thread while it reads from disk. This leads to slow app launches or even ANRs (Application Not Responding) on Android.
• Error handling headaches: Synchronous creation throws errors immediately, which can crash your app if not caught properly. Realm.open() lets you handle errors gracefully with .catch() or try/catch in async/await.
• Resource management: A global instance requires you to manually manage when to close it. If you forget to close it when your app is backgrounded or unmounted, you risk memory leaks or database corruption.

The Correct Practices #

1. Use Realm.open() with React Hooks (Recommended for Components) #

Wrap Realm.open() in a custom hook to handle instance lifecycle safely. This ensures the Realm is opened when the component mounts, closed when it unmounts, and leverages Realm’s internal caching. Here’s a simple example:

import { useEffect, useState } from 'react';
import Realm from 'realm';

export function useRealm(schema) {
  const [realm, setRealm] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let isMounted = true;

    const openRealm = async () => {
      try {
        const openedRealm = await Realm.open({ schema });
        if (isMounted) {
          setRealm(openedRealm);
          setLoading(false);
        }
      } catch (err) {
        if (isMounted) {
          setError(err);
          setLoading(false);
        }
      }
    };

    openRealm();

    return () => {
      isMounted = false;
      if (realm && !realm.isClosed) {
        realm.close();
      }
    };
  }, [schema]);

  return { realm, loading, error };
}

Then use it in your components like this:

import { useRealm } from './hooks';

function MyComponent() {
  const { realm, loading, error } = useRealm([YourSchema]);

  if (loading) return <Text>Loading...</Text>;
  if (error) return <Text>Error: {error.message}</Text>;

  // Use realm instance safely
  const items = realm.objects('YourSchema');
  return <FlatList data={items} renderItem={...} />;
}

2. Global Instance (For Non-Component Code) #

If you need a Realm instance in utility functions or redux thunks, initialize it asynchronously at app startup instead of using new Realm():

import Realm from 'realm';
import { useEffect } from 'react';

let globalRealm = null;
const realmInitPromise = Realm.open({ schema: [YourSchema] })
  .then(realm => {
    globalRealm = realm;
    return realm;
  })
  .catch(err => console.error('Failed to initialize global Realm:', err));

// Helper function to get the global instance safely
export async function getGlobalRealm() {
  if (!globalRealm) {
    await realmInitPromise;
  }
  return globalRealm;
}

// In your root App component, handle cleanup
export function App() {
  useEffect(() => {
    return () => {
      if (globalRealm && !globalRealm.isClosed) {
        globalRealm.close();
      }
    };
  }, []);

  // Rest of your app code
}

This way, you avoid blocking the main thread, ensure the instance is ready before use, and still get the convenience of a global access point.

Final Takeaway #

Don’t stress about Realm.open() being inefficient—its internal caching takes care of that. Avoid synchronous new Realm() unless you’re 100% sure the database is already initialized and won’t block the UI. Stick to async methods with proper lifecycle management for the most reliable, performant code.

内容的提问来源于stack exchange，提问作者user6791424