Android Studio调用myThread.ThreadHandler.obtainMessage()触发空指针异常

核心问题 #

1. 跨进程调用错误：你的Service配置了独立进程android:process=":connectedDevice_process"，但MainActivity直接调用Service的SetActivityStatus方法——这是错误的，因为不同进程的对象完全隔离，你调用的只是MainActivity进程里的Service代理实例，而非独立进程中真正初始化了myThread的Service对象，所以myThread会是空引用。
2. LooperThread初始化时机问题：即使是同一进程，ThreadHandler是在LooperThread的run()方法中初始化的，如果在线程未完全启动时就尝试获取ThreadHandler，也会触发空指针。

解决方案 #

1. 替换跨进程直接调用：用Messenger实现进程间通信 #

因为Service在独立进程，必须用进程间通信（IPC）机制传递指令，推荐用Messenger（适合简单的单向通信场景）：

步骤1：改造MyBLEService

public class MyBLEService extends Service {
    public static final int MSG_START_BLE_SCAN = 1001;
    private LooperThread myThread;
    private Messenger serviceMessenger;

    // 自定义Looper线程，负责BLE扫描逻辑
    private class LooperThread extends Thread {
        public Handler threadHandler;

        @Override
        public void run() {
            Looper.prepare();
            // 初始化Handler，绑定当前线程的Looper
            threadHandler = new Handler(Looper.myLooper()) {
                @Override
                public void handleMessage(Message msg) {
                    switch (msg.what) {
                        case MSG_START_BLE_SCAN:
                            // 执行BLE扫描逻辑
                            startPeriodicBLEScan();
                            break;
                        default:
                            super.handleMessage(msg);
                    }
                }
            };
            Looper.loop();
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        // 启动Looper线程
        myThread = new LooperThread();
        myThread.start();
        // 等待线程初始化Handler（可用CountDownLatch做更可靠的等待，避免直接延迟）
        new Handler().postDelayed(() -> {
            serviceMessenger = new Messenger(myThread.threadHandler);
        }, 500);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return serviceMessenger != null ? serviceMessenger.getBinder() : null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // 通知MainActivity服务就绪（用广播实现跨进程通知）
        sendServiceReadyBroadcast();
        return START_STICKY;
    }

    private void startPeriodicBLEScan() {
        // 你的定期BLE扫描逻辑
    }

    private void sendServiceReadyBroadcast() {
        Intent broadcastIntent = new Intent("com.example.got_u.SERVICE_READY");
        sendBroadcast(broadcastIntent);
    }
}

步骤2：改造MainActivity，通过绑定Service发送指令

public class MainActivity extends AppCompatActivity {
    private Messenger serviceMessenger;
    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            serviceMessenger = new Messenger(service);
            // 服务绑定成功，发送扫描指令
            sendStartScanMessage();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            serviceMessenger = null;
        }
    };

    private BroadcastReceiver serviceReadyReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // 收到服务就绪通知，绑定Service
            bindService(new Intent(MainActivity.this, MyBLEService.class), 
                        serviceConnection, BIND_AUTO_CREATE);
            // 启用Fragment
            getSupportFragmentManager().beginTransaction()
                .replace(R.id.container, new YourScanFragment())
                .commit();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 注册广播接收器，监听服务就绪通知
        registerReceiver(serviceReadyReceiver, new IntentFilter("com.example.got_u.SERVICE_READY"));
        // 启动Service
        startService(new Intent(this, MyBLEService.class));
    }

    private void sendStartScanMessage() {
        if (serviceMessenger == null) return;
        Message msg = Message.obtain(null, MyBLEService.MSG_START_BLE_SCAN);
        try {
            serviceMessenger.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(serviceReadyReceiver);
        if (serviceMessenger != null) {
            unbindService(serviceConnection);
        }
    }
}

2. 补充安全校验：避免空指针 #

无论是否跨进程，在访问threadHandler前必须加空判断：

if (myThread != null && myThread.threadHandler != null) {
    Message msg = myThread.threadHandler.obtainMessage();
    // 发送消息逻辑
} else {
    // 线程未初始化完成，重试或抛出提示
}

3. 独立进程注意事项 #

• 独立进程的Service与主进程完全隔离，静态变量、全局对象无法共享，所有通信必须通过IPC机制（Messenger、AIDL、Broadcast等）。
• 独立进程的Service需要单独处理生命周期，避免内存泄漏，确保在不需要时调用stopSelf()终止。

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