Activity原理与生命周期

发布时间: 2025-03-22 13:09

↑

# Activity原理与生命周期

本文将详细介绍Android系统中Activity组件的工作原理和生命周期管理机制,帮助读者深入理解Activity的运行机制。

## Activity概述

### 1. 定义与作用

Activity是Android应用程序的基本组件之一,主要负责：

- 提供用户界面
- 处理用户交互
- 管理应用窗口
- 实现页面导航

### 2. 基本特性

- 具有完整的生命周期
- 可以包含多个Fragment
- 支持任务栈管理
- 可以处理各种Intent

## 生命周期

### 1. 生命周期方法

```java
public class ExampleActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 活动创建时调用
        // 进行初始化操作
        setContentView(R.layout.activity_main);
    }

@Override
    protected void onStart() {
        super.onStart();
        // 活动变为可见时调用
        // 准备与用户交互
    }

@Override
    protected void onResume() {
        super.onResume();
        // 活动获取焦点时调用
        // 开始与用户交互
    }

@Override
    protected void onPause() {
        super.onPause();
        // 活动失去焦点时调用
        // 保存关键数据
    }

@Override
    protected void onStop() {
        super.onStop();
        // 活动不可见时调用
        // 释放系统资源
    }

@Override
    protected void onDestroy() {
        super.onDestroy();
        // 活动销毁时调用
        // 清理资源
    }

@Override
    protected void onRestart() {
        super.onRestart();
        // 停止状态重新启动时调用
    }
}
```

### 2. 生命周期状态

1. Created状态
   - onCreate()方法执行
   - 初始化界面
   - 绑定数据

2. Started状态
   - onStart()方法执行
   - 活动可见但不可交互
   - 准备资源

3. Resumed状态
   - onResume()方法执行
   - 活动可见且可交互
   - 处理用户输入

4. Paused状态
   - onPause()方法执行
   - 活动部分可见
   - 停止动画等消耗资源的操作

5. Stopped状态
   - onStop()方法执行
   - 活动完全不可见
   - 释放重量级资源

6. Destroyed状态
   - onDestroy()方法执行
   - 活动即将销毁
   - 清理所有资源

## 启动模式

### 1. standard模式

```xml

<activity
    android:name=".StandardActivity"
    android:launchMode="standard" />
```

- 默认启动模式
- 每次启动都创建新实例
- 可以多次创建

### 2. singleTop模式

```xml
<activity
    android:name=".SingleTopActivity"
    android:launchMode="singleTop" />
```

- 栈顶复用
- 避免重复创建
- 适合接收通知的页面

### 3. singleTask模式

```xml
<activity
    android:name=".SingleTaskActivity"
    android:launchMode="singleTask" />
```

- 栈内复用
- 清除上层实例
- 适合应用主页面

### 4. singleInstance模式

```xml
<activity
    android:name=".SingleInstanceActivity"
    android:launchMode="singleInstance" />
```

- 单独任务栈
- 全局唯一
- 适合特殊界面

## 任务栈管理

### 1. 基本概念

```java
// 任务栈相关API
public class TaskStackDemo extends Activity {
    private void manipulateTaskStack() {
        // 获取任务栈ID
        int taskId = getTaskId();
        
        // 将Activity移至前台
        moveTaskToFront();
        
        // 清理任务栈
        finishAndRemoveTask();
        
        // 获取任务栈信息
        ActivityManager.TaskDescription taskDescription =
            new ActivityManager.TaskDescription();
    }
}
```

### 2. 任务栈属性

```xml
<activity
    android:name=".TaskActivity"
    android:taskAffinity="com.example.task"
    android:allowTaskReparenting="true"
    android:clearTaskOnLaunch="false"
    android:alwaysRetainTaskState="true" />
```

### 3. 管理方法

```java
// 任务栈管理示例
public class TaskManagement {
    public void manageTasks(Context context) {
        ActivityManager am = (ActivityManager)
            context.getSystemService(Context.ACTIVITY_SERVICE);
            
        // 获取运行中的任务
        List<ActivityManager.AppTask> tasks = am.getAppTasks();
        
        // 遍历任务栈
        for (ActivityManager.AppTask task : tasks) {
            // 获取任务信息
            ActivityManager.TaskDescription description =
                task.getTaskInfo().taskDescription;
                
            // 移除任务
            task.finishAndRemoveTask();
        }
    }
}
```

## 状态保存与恢复

### 1. 保存状态

```java
public class StateActivity extends Activity {
    private static final String KEY_COUNTER = "counter";
    private int counter;
    
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        // 保存状态
        outState.putInt(KEY_COUNTER, counter);
    }
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState != null) {
            // 恢复状态
            counter = savedInstanceState.getInt(KEY_COUNTER);
        }
    }
}
```

### 2. 持久化数据

```java
public class DataPersistence extends Activity {
    private static final String PREF_NAME = "activity_state";
    
    private void saveData() {
        // 使用SharedPreferences
        SharedPreferences.Editor editor =
            getSharedPreferences(PREF_NAME, MODE_PRIVATE).edit();
        editor.putString("key", "value");
        editor.apply();
        
        // 使用文件存储
        try {
            FileOutputStream fos =
                openFileOutput("data.txt", Context.MODE_PRIVATE);
            fos.write("data".getBytes());
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
```

## Activity通信

### 1. Intent通信

```java
// 启动Activity
Intent intent = new Intent(this, TargetActivity.class);
intent.putExtra("key", "value");
startActivity(intent);

// 获取结果
startActivityForResult(intent, REQUEST_CODE);

@Override
protected void onActivityResult(int requestCode,
                               int resultCode,
                               Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == REQUEST_CODE && resultCode == RESULT_OK) {
        String result = data.getStringExtra("result");
    }
}
```

### 2. 事件总线

```java
// 使用EventBus
public class EventBusActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        EventBus.getDefault().register(this);
    }
    
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEvent(MessageEvent event) {
        // 处理事件
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        EventBus.getDefault().unregister(this);
    }
}
```

## 性能优化

### 1. 生命周期优化

```java
public class OptimizedActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 延迟加载
        postponeEnterTransition();
        
        // 异步初始化
        new Thread(() -> {
            // 耗时操作
            runOnUiThread(() -> {
                // 更新UI
                startPostponedEnterTransition();
            });
        }).start();
    }
    
    @Override
    protected void onResume() {
        super.onResume();
        // 避免重复加载
        if (!isDataLoaded) {
            loadData();
        }
    }
}
```

### 2. 内存优化

```java
public class MemoryOptimizedActivity extends Activity {
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 释放资源
        releaseResources();
    }
    
    private void releaseResources() {
        // 取消异步任务
        if (asyncTask != null) {
            asyncTask.cancel(true);
        }
        
        // 清理缓存
        clearCache();
        
        // 解除监听
        unregisterListeners();
    }
}
```

## 最佳实践

### 1. 生命周期处理

1. 正确实现生命周期方法
   - 调用super方法
   - 避免耗时操作
   - 及时释放资源

2. 状态保存与恢复
   - 保存必要数据
   - 处理配置变化
   - 避免保存大量数据

### 2. 启动模式选择

1. standard模式
   - 普通界面
   - 允许多实例

2. singleTop模式
   - 通知处理页面
   - 避免重复创建

3. singleTask模式
   - 应用主页面
   - 重要节点页面

4. singleInstance模式
   - 特殊功能界面
   - 独立任务栈

### 3. 性能优化建议

1. 布局优化
   - 避免过度嵌套
   - 使用ViewStub
   - 合理使用merge标签

2. 初始化优化
   - 延迟加载
   - 异步初始化
   - 避免ANR

3. 内存优化
   - 及时释放资源
   - 避免内存泄漏
   - 处理好生命周期

## 总结

Activity是Android应用的核心组件,其特点包括：

1. 完整的生命周期
   - 创建到销毁的完整管理
   - 状态转换的可控性
   - 资源管理的规范性

2. 灵活的启动模式
   - 多种启动方式
   - 任务栈管理
   - 实例复用机制

3. 丰富的通信机制
   - Intent传递数据
   - 结果回调
   - 事件总线

开发者在使用Activity时应该：

1. 理解生命周期机制
2. 正确选择启动模式
3. 做好性能优化
4. 注意内存管理

元素码农