正文

Android编程实例分析从按钮点击无响应到解决App卡顿崩溃的实用指南

/0 浏览量
0921

Android编程实例分析从按钮点击无响应到解决App卡顿崩溃的实用指南

那些年我们踩过的坑

做Android开发的朋友，谁还没经历过这样一个场景：APP发布上线后，用户反馈”按钮点不动”，你本地测试明明正常，排查半天才发现是主线程阻塞导致的。或者更惨的，直接ANR（Application Not Responding）弹窗，用户直接卸载。今天咱们就聊聊这些问题，把常见的坑都填平。

按钮点击无响应的真实原因

先说一个实际案例。我之前接手过一个项目，用户反馈登录按钮有时候点了几次都没反应。本地测试完全没问题，日志也查不到异常。后来用StrictMode一测，发现问题所在。

常见原因一：主线程阻塞

Android的主线程（UI线程）负责处理所有UI操作和用户交互。如果主线程被阻塞，按钮点击事件就得不到响应。

public class MainActivity extends AppCompatActivity {
    
    private Button loginButton;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        loginButton = findViewById(R.id.loginButton);
        loginButton.setOnClickListener(v -> {
            // 错误做法：在主线程执行耗时操作
            String username = etUsername.getText().toString();
            String password = etPassword.getText().toString();
            
            // 这个网络请求会阻塞主线程！
            String response = performNetworkRequest(username, password);
            
            // 只有拿到结果才会执行到下面
            showResult(response);
        });
    }
    
    private String performNetworkRequest(String user, String pass) {
        // 模拟网络请求，耗时5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "{\"status\":\"success\"}";
    }
}

这段代码看起来没问题，但实际上performNetworkRequest在主线程执行5秒，用户点击按钮后5秒内完全无响应。如果网络请求更慢，或者你执行了多个串行操作，卡顿就更明显了。

常见原因二：事件被拦截或消费

有时候按钮点了没反应，是因为事件传递链出了问题：

public class CustomContainer extends FrameLayout {
    
    public CustomContainer(Context context) {
        super(context);
    }
    
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        // 问题：这里没有调用super，事件没有被正确分发
        // 解决方案：要么调用super，要么手动处理并返回true
        return super.dispatchTouchEvent(ev);
    }
    
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        // 问题：无条件拦截所有事件
        return true; 
    }
}

常见原因三：动态注册监听器时机不对

public class MyFragment extends Fragment {
    
    private Button actionButton;
    
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_my, container, false);
        actionButton = view.findViewById(R.id.actionButton);
        
        // 问题：如果在onViewCreated之前就尝试获取按钮并设置监听器
        // 或者多次重复设置监听器但没有清理，会导致行为异常
        return view;
    }
    
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        
        // 正确做法：在onViewCreated中设置监听器
        actionButton.setOnClickListener(v -> {
            performAction();
        });
    }
}

如何诊断按钮无响应

使用StrictMode检测主线程阻塞

public class MyApplication extends Application {
    
    @Override
    public void onCreate() {
        super.onCreate();
        
        // 在Debug版本中启用StrictMode
        if (BuildConfig.DEBUG) {
            StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
                    .detectDiskReads()        // 检测磁盘读操作
                    .detectDiskWrites()      // 检测磁盘写操作
                    .detectNetwork()         // 检测网络操作
                    .penaltyLog()            // 打印日志
                    .penaltyDialog()         // 弹出对话框（可选）
                    .build());
            
            StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
                    .detectLeakedSqlLiteObjects()
                    .detectLeakedClosableObjects()
                    .penaltyLog()
                    .build());
        }
    }
}

添加这段代码后，如果你在主线程执行了IO或网络操作，Logcat会打印类似这样的警告：

StrictMode policy violation; android.os.StrictMode$StrictModeDiskReadViolation

使用Layout Inspector排查事件拦截

Android Studio内置的Layout Inspector工具可以实时查看View树的状态，包括触摸事件的分发情况。在”Profile”窗口中打开，然后点击按钮，看看事件是否被正确传递到目标View。

解决按钮点击无响应的正确姿势

方案一：使用协程处理耗时操作

class MainActivity : AppCompatActivity() {
    
    private lateinit var binding: ActivityMainBinding
    private val viewModel: MainViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        binding.loginButton.setOnClickListener {
            // 启动协程处理登录
            lifecycleScope.launch {
                // 显示加载状态
                binding.progressBar.visibility = View.VISIBLE
                
                try {
                    // 切换IO线程执行网络请求
                    val result = viewModel.login(
                        binding.usernameEditText.text.toString(),
                        binding.passwordEditText.text.toString()
                    )
                    
                    // 自动回到主线程更新UI
                    if (result.success) {
                        Toast.makeText(this@MainActivity, "登录成功", Toast.LENGTH_SHORT).show()
                        navigateToHome()
                    } else {
                        Toast.makeText(this@MainActivity, result.message, Toast.LENGTH_SHORT).show()
                    }
                } catch (e: Exception) {
                    Toast.makeText(this@MainActivity, "登录失败: ${e.message}", Toast.LENGTH_SHORT).show()
                } finally {
                    // 隐藏加载状态
                    binding.progressBar.visibility = View.GONE
                }
            }
        }
    }
    
    private fun navigateToHome() {
        startActivity(Intent(this, HomeActivity::class.java))
        finish()
    }
}

对应的ViewModel：

class MainViewModel : ViewModel() {
    
    private val repository: AuthRepository = AuthRepository()
    
    suspend fun login(username: String, password: String): LoginResult {
        return try {
            // 网络请求在IO线程执行
            val response = repository.authenticate(username, password)
            if (response.isSuccessful) {
                LoginResult(success = true)
            } else {
                LoginResult(success = false, message = "用户名或密码错误")
            }
        } catch (e: IOException) {
            LoginResult(success = false, message = "网络连接失败")
        }
    }
}

data class LoginResult(
    val success: Boolean,
    val message: String = ""
)

方案二：使用Executors（兼容旧项目）

public class LegacyMainActivity extends AppCompatActivity {
    
    private static final Executor MAIN_THREAD_EXECUTOR = 
        ContextCompat.getMainExecutor(this);
    
    private static final Executor IO_EXECUTOR = 
        Executors.newFixedThreadPool(4);
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        Button loginButton = findViewById(R.id.loginButton);
        loginButton.setOnClickListener(v -> {
            String username = getUsername();
            String password = getPassword();
            
            // 切换到IO线程执行耗时操作
            IO_EXECUTOR.execute(() -> {
                LoginResult result = performLogin(username, password);
                
                // 结果回调到主线程
                MAIN_THREAD_EXECUTOR.execute(() -> {
                    if (result.isSuccess) {
                        navigateToHome();
                    } else {
                        showError(result.getMessage());
                    }
                });
            });
        });
    }
    
    private LoginResult performLogin(String user, String pass) {
        // 耗时操作
        return new LoginResult(true);
    }
}

App卡顿的根源与解决方案

卡顿比按钮无响应更常见，表现是界面滑动不流畅、动画掉帧。核心问题就一个：主线程做了不该做的事情。

卡顿检测工具

// 在Application中配置
class TracingApp : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // 使用Choreographer检测卡顿
        Choreographer.getInstance().postFrameCallback(object : Choreographer.FrameCallback {
            override fun doFrame(frameTimeNanos: Long) {
                // 如果frameTimeNanos比预期值大很多，说明有卡顿
                val expectedInterval = 16_666_667L // 60fps
                if (frameTimeNanos - lastFrameTime > expectedInterval * 2) {
                    Log.w(TAG, "检测到卡顿: ${frameTimeNanos - lastFrameTime} ns")
                }
                lastFrameTime = frameTimeNanos
                Choreographer.getInstance().postFrameCallback(this)
            }
        })
    }
    
    companion object {
        private var lastFrameTime = 0L
        private const val TAG = "TracingApp"
    }
}

布局优化：减少View层级

<!-- 错误示例：过多的嵌套 -->
<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical">
    
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="标题"/>
            
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="副标题"/>
    </LinearLayout>
</LinearLayout>

<!-- 正确示例：使用ConstraintLayout扁平化 -->
<androidx.constraintlayout.widget.ConstraintLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content">
    
    <TextView
        android:id="@+id/title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="标题"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"/>
        
    <TextView
        android:id="@+id/subtitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="副标题"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/title"/>
        
</androidx.constraintlayout.widget.ConstraintLayout>

使用Android Studio的”Layout Inspector”查看View层级，或者在代码中调用：

// 打印布局层级，查找多余嵌套
rootView.debugLayoutHierarchy()

fun View.debugLayoutHierarchy(indent: String = "") {
    println("$indent${this::class.simpleName} @ ${id}")
    if (this is ViewGroup) {
        for (i in 0 until childCount) {
            getChildAt(i).debugLayoutHierarchy("$indent  ")
        }
    }
}

RecyclerView优化

class OptimizedRecyclerViewActivity : AppCompatActivity() {
    
    private lateinit var binding: ActivityRecyclerviewBinding
    private lateinit var adapter: ItemAdapter
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityRecyclerviewBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        setupRecyclerView()
    }
    
    private fun setupRecyclerView() {
        adapter = ItemAdapter()
        
        binding.recyclerView.apply {
            // 固定大小，避免每次测量
            setHasFixedSize(true)
            
            // 设置LayoutManager
            layoutManager = LinearLayoutManager(this@OptimizedRecyclerViewActivity)
            
            // 设置Adapter
            adapter = adapter
            
            // 添加分隔线
            addItemDecoration(DividerItemDecoration(this@OptimizedRecyclerViewActivity, DividerItemDecoration.VERTICAL))
            
            // 开启局部刷新优化
            adapter.setHasStableIds(true)
        }
        
        // 预取数量，减少卡顿
        binding.recyclerView.itemAnimator = SimpleItemAnimator().apply {
            supportsChangeAnimations = false // 关闭改变动画提升性能
        }
    }
}

class ItemAdapter : RecyclerView.Adapter<ItemAdapter.ViewHolder>() {
    
    private val items = mutableListOf<String>()
    
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_simple, parent, false)
        return ViewHolder(view)
    }
    
    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        // 只绑定必要的数据
        holder.bind(items[position])
    }
    
    override fun getItemCount() = items.size
    
    class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        private val textView: TextView = view.findViewById(R.id.textView)
        
        fun bind(text: String) {
            textView.text = text
        }
    }
}

崩溃的常见原因与预防

空指针异常（NPE）

// 危险的做法
val text = textView.text.toString() // textView可能为null
val length = text.length // 如果text是null，直接崩溃

// 安全的做法
val text = textView?.text?.toString() ?: ""
val length = text.length

// 或者使用requireNotNull
val safeView = requireNotNull(findViewById<View>(R.id.myView)) {
    "View myView must exist"
}

数组越界

// 错误
val item = items[position] // position可能越界

// 正确
val item = items.getOrNull(position) // 越界返回null
// 或者
if (position in items.indices) {
    val item = items[position]
}

资源泄漏导致的崩溃

// 使用AutoCloseable确保资源释放
class DataManager private constructor(private val context: Context) {
    
    private var database: RoomDatabase? = null
    
    suspend fun init() {
        database = Room.databaseBuilder(
            context,
            AppDatabase::class.java,
            "app_database"
        ).build()
    }
    
    fun close() {
        database?.close()
        database = null
    }
}

// 在Activity中使用try-with-resources模式
class MainActivity : AppCompatActivity() {
    
    private lateinit var dataManager: DataManager
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        dataManager = DataManager(this)
        // 使用协程生命周期自动管理
    }
    
    override fun onDestroy() {
        super.onDestroy()
        dataManager.close()
    }
}

完整的崩溃处理与监控方案

class CrashHandler : Thread.UncaughtExceptionHandler {
    
    private val defaultHandler: Thread.UncaughtExceptionHandler = 
        Thread.getDefaultUncaughtExceptionHandler()!!
    
    override fun uncaughtException(thread: Thread, ex: Throwable) {
        // 1. 记录崩溃日志
        logCrash(ex)
        
        // 2. 上报到服务器
        reportCrash(ex)
        
        // 3. 显示友好提示
        showCrashDialog()
        
        // 4. 交由系统处理或退出应用
        defaultHandler.uncaughtException(thread, ex)
    }
    
    private fun logCrash(exception: Throwable) {
        val log = StringBuilder()
        log.append("时间: ${SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(Date())}\n")
        log.append("设备: ${Build.MODEL}\n")
        log.append("系统: ${Build.VERSION.RELEASE}\n")
        log.append("异常: $exception\n")
        log.append("\n堆栈:\n")
        
        val sw = StringWriter()
        exception.printStackTrace(PrintWriter(sw))
        log.append(sw.toString())
        
        // 保存到文件
        val file = File(getLogDirectory(), "crash_${System.currentTimeMillis()}.log")
        file.writeText(log.toString())
        
        // 发送广播通知日志服务
        sendBroadcast(Intent("com.app.LOG_CRASH").apply {
            putExtra("log", log.toString())
        })
    }
    
    private fun reportCrash(exception: Throwable) {
        // 异步上报，避免阻塞
        CoroutineScope(Dispatchers.IO).launch {
            try {
                val crashReport = CrashReport(
                    timestamp = System.currentTimeMillis(),
                    deviceModel = Build.MODEL,
                    androidVersion = Build.VERSION.RELEASE,
                    exceptionClass = exception.javaClass.name,
                    message = exception.message,
                    stackTrace = getStackTrace(exception)
                )
                
                // 上传到服务器
                FirebaseCrashlytics.getInstance().recordException(exception)
                // 或者自定义上报
                // crashReporter.upload(crashReport)
                
            } catch (e: Exception) {
                // 上报失败也要处理
                Log.e("CrashHandler", "上报失败", e)
            }
        }
    }
    
    private fun showCrashDialog() {
        // 在主线程显示
        Handler(Looper.getMainLooper()).post {
            try {
                val dialog = AlertDialog.Builder(this)
                    .setTitle("程序异常")
                    .setMessage("应用遇到意外错误，即将重启。")
                    .setPositiveButton("重启") { _, _ ->
                        restartApp()
                    }
                    .setCancelable(false)
                    .show()
            } catch (e: Exception) {
                // 如果弹对话框也崩溃，直接重启
                restartApp()
            }
        }
    }
    
    private fun restartApp() {
        val intent = packageManager.getLaunchIntentForPackage(packageName)
        intent?.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
        startActivity(intent)
        Process.killProcess(Process.myPid())
    }
    
    private fun getStackTrace(exception: Throwable): String {
        val sw = StringWriter()
        exception.printStackTrace(PrintWriter(sw))
        return sw.toString()
    }
}

// 在Application中注册
class MyApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // 注册崩溃处理器
        Thread.setDefaultUncaughtExceptionHandler(CrashHandler())
    }
}

性能监控的最佳实践

自定义性能埋点

class PerformanceMonitor {
    
    companion object {
        private val startTimeMap = HashMap<String, Long>()
        private val eventCountMap = HashMap<String, Int>()
        
        fun startTransaction(tag: String) {
            startTimeMap[tag] = SystemClock.elapsedRealtime()
        }
        
        fun endTransaction(tag: String) {
            val start = startTimeMap.remove(tag) ?: return
            val duration = SystemClock.elapsedRealtime() - start
            
            Log.d("Performance", "$tag: $duration ms")
            
            // 超过500ms记录警告
            if (duration > 500) {
                Log.w("Performance", "$tag 耗时过长: $duration ms")
            }
        }
        
        fun incrementEvent(tag: String) {
            eventCountMap[tag] = eventCountMap.getOrElse(tag) { 0 } + 1
        }
        
        fun getEventCount(tag: String): Int {
            return eventCountMap[tag] ?: 0
        }
    }
}

// 使用示例
class NetworkService {
    
    suspend fun fetchData(): Data {
        PerformanceMonitor.startTransaction("network_fetch")
        return try {
            val result = api.call()
            PerformanceMonitor.incrementEvent("network_success")
            result
        } catch (e: Exception) {
            PerformanceMonitor.incrementEvent("network_error")
            throw e
        } finally {
            PerformanceMonitor.endTransaction("network_fetch")
        }
    }
}

使用Perfetto或Systrace进行深入分析

对于复杂的卡顿问题，系统级的性能分析工具必不可少：

# 使用systrace捕获2秒的CPU和渲染信息
python systrace.py -t 2 -o trace.html sched freq wm am view

# 使用Perfetto（推荐，功能更强大）
# 在Android Studio的Device File Explorer中找到perfetto.tracedb

总结

从按钮点击无响应到App卡顿崩溃，这些问题本质上都是同一个根源：主线程被不该做的事情占用。解决思路很清晰：

  1. 诊断先行：用StrictMode、Layout Inspector、Choreographer等工具定位问题
  2. 异步处理：耗时操作必须放到后台线程，Kotlin协程是最佳选择
  3. 布局优化：减少View层级，使用ConstraintLayout和RecyclerView的正确姿势
  4. 防御性编程：空安全、边界检查、资源释放
  5. 监控兜底：崩溃捕获、性能埋点、及时上报

记住一个原则：主线程只负责UI更新和用户交互，其他一切都交给后台。只要守住这条底线，大部分卡顿和崩溃问题都能避免。

-- 展开阅读全文 --