薛乔铭

在安卓开发中，多线程几乎是随时都会用到的，尤其是涉及 耗时操作 或 异步处理 的场景，否则主线程（UI线程）会被阻塞，导致卡顿甚至 ANR（应用无响应）。
1️⃣ 网络请求

原因：HTTP 请求、WebSocket、Socket 通信等都是耗时操作。

实现方式：

RxJava

OkHttp异步回调

Coroutine（Kotlin）

AsyncTask（过时）

new Thread(() -> {
    String result = httpRequest();
    runOnUiThread(() -> textView.setText(result));
}).start();

2️⃣ 数据库操作

查询、插入、更新大量数据时，操作可能很慢。

实现方式：

Room + LiveData / RxJava / Coroutine

自己开子线程执行数据库操作

new Thread(() -> {
    List<User> users = db.userDao().getAllUsers();
    runOnUiThread(() -> adapter.setData(users));
}).start();

3️⃣ 文件 I/O

读写本地文件、图片、视频、大数据文件。

大文件操作会阻塞主线程，必须放子线程。

ExecutorService executor = Executors.newSingleThreadExecutor();
executor.execute(() -> {
    File file = new File(path);
    writeToFile(file, content);
});

4️⃣ 图片加载 / 视频解码

Bitmap解码、视频帧处理、GIF播放。

常用工具：Glide、Fresco、ExoPlayer，本质都是在子线程处理。

5️⃣ 计时 / 定时任务

倒计时、定时上传数据、心跳包。

使用 Handler、ScheduledThreadPoolExecutor 或 TimerTask。

6️⃣ 复杂计算 / 算法

路径规划、图像处理、机器学习推理。

都要在子线程中执行，避免 UI 卡顿。

7️⃣ 消息 / 事件处理

子线程收到消息或数据，需要更新 UI。

用法：

Handler + Looper

runOnUiThread

View.post()

✅ 总结

多线程的本质目的是避免阻塞UI线程，凡是耗时操作、重复任务或异步事件，都会用到多线程。

1️⃣ rectangle（矩形）

最常用的形状。

可以通过 cornerRadius 设置圆角。

示例：

<shape android:shape="rectangle">
    <solid android:color="#FF0000"/>
    <corners android:radius="8dp"/>
</shape>

2️⃣ oval（椭圆 / 圆）

如果宽高相等就是圆形。

可用于圆形按钮或头像背景。

3️⃣ line（直线）

表示一条线，需要设置 size 的 height 或 width 才能显示。

示例：

<shape android:shape="line">
    <size android:height="2dp"/>
    <solid android:color="#000000"/>
</shape>

4️⃣ ring（环 / 圆环）

用于画圆环或进度条背景。

需要设置 innerRadius（内半径）、thickness（环宽）。

示例：

<shape android:shape="ring">
    <size android:width="100dp" android:height="100dp"/>
    <solid android:color="#00FF00"/>
    <ring
        android:innerRadius="30dp"
        android:thickness="10dp"/>
</shape>

⚡ 总结
形状	说明	用途示例
rectangle	矩形，可加圆角	按钮、背景、卡片
oval	椭圆或圆	圆形按钮、头像
line	一条直线	分割线
ring	圆环	环形进度条

左下角点击分支：
HEAD(Current Branch)
Local
   master  (鼠标右键，new branch)

Remote
   origin
         master


修改新建的分支一点代码，然后提交，就会在远程仓库看到新分支

如果要合并新分支代码到主分支：
     先local下先切换回主分支(checkout)
     再点击新建的分支：merge into master
     合并后直接再主分支git  push，远程分支就修改了
            

📌 1. 普通 Java 单例 (应用级)
public class MySingleton {
    private static MySingleton instance;
    private MySingleton() {}
    public static MySingleton getInstance() {
        if (instance == null) instance = new MySingleton();
        return instance;
    }
}


instance 静态变量挂在 类加载器 上，只要这个类还在内存里，就不会销毁。

在 Android 应用进程退出时（系统杀掉应用进程），单例实例才会被回收。

如果你手动写 instance = null;，垃圾回收器（GC）可能在之后清理。

👉 结论：这种单例和应用进程同生共死。

📌 2. 带 Context 的单例
public class MyManager {
    private static MyManager instance;
    private Context context;
    private MyManager(Context context) {
        this.context = context.getApplicationContext(); // 必须用 ApplicationContext！
    }
    public static synchronized MyManager getInstance(Context context) {
        if (instance == null) instance = new MyManager(context);
        return instance;
    }
}


如果保存了 Activity Context，那么 Activity 销毁时无法释放，可能导致 内存泄漏。

如果保存了 Application Context，那就和进程同生共死，进程退出才销毁。

📌 3. Kotlin object 单例
object MySingleton {
    fun doSomething() {}
}


这种实现其实就是 静态类，生命周期 = 应用进程生命周期。

进程被杀时销毁。

📌 4. 依赖注入框架中的单例 (如 Dagger/Hilt)

“单例”受 容器管理，并不一定等于应用级单例。

如果是 @Singleton，一般和 Application 同生命周期。

如果是作用域内的（比如 ActivityScope），在 Activity 销毁时就会释放。

✅ 总结：

如果是自己写的 静态单例，通常 只有在应用进程被杀死时才会销毁。

如果单例里引用了 短生命周期对象（Activity、Service），那会导致泄漏，除非手动释放。

想要提前销毁，可以手动 instance = null;，然后等待 GC 回收。


单例（Singleton）生命周期等于整个进程，如果单例里直接引用了 短生命周期对象（如 Activity、Service、Context 等），在这些对象销毁后单例仍然持有引用，就会造成 内存泄漏。
✅ 预防方法
1. 不要在单例中保存短生命周期对象
2. 使用 WeakReference
如果确实要持有短生命周期对象，用 WeakReference 包装，避免强引用阻止回收。
3. 用回调时解绑
单例常做事件分发或回调管理，这种情况下要记得 在 Activity/Service 销毁时解除注册。

1️⃣ EasyPermissions（Google 官方推荐）

GitHub: https://github.com/googlesamples/easypermissions

特点：

基于 Activity/Fragment 封装权限请求

支持一次请求多个权限

自动处理“不再询问”提示

示例：

String[] perms = {Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO};
if (EasyPermissions.hasPermissions(this, perms)) {
    // 已有权限
    startCamera();
} else {
    EasyPermissions.requestPermissions(
        this,
        "需要相机和麦克风权限",
        123,
        perms
    );
}


回调：

@Override
public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) { }

@Override
public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) { }

2️⃣ AndPermission

GitHub: https://github.com/yanzhenjie/AndPermission

特点：

API 更现代化，支持链式调用

支持权限分组、申请多个权限

支持“去设置页面引导”

示例：

AndPermission.with(this)
    .runtime()
    .permission(Permission.CAMERA, Permission.RECORD_AUDIO)
    .onGranted(permissions -> {
        // 权限允许
        startCamera();
    })
    .onDenied(permissions -> {
        // 权限拒绝
        Toast.makeText(this, "权限被拒绝", Toast.LENGTH_SHORT).show();
    })
    .start();

3️⃣ RxPermissions（RxJava 结合）

GitHub: https://github.com/tbruyelle/RxPermissions

特点：

使用 RxJava 响应式方式请求权限

链式写法更优雅，适合 RxJava 项目

示例：

RxPermissions rxPermissions = new RxPermissions(this);
rxPermissions
    .request(Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO)
    .subscribe(granted -> {
        if (granted) {
            startCamera();
        } else {
            Toast.makeText(this, "权限被拒绝", Toast.LENGTH_SHORT).show();
        }
    });

🔹 总结
库	优点	适合场景
EasyPermissions	Google 官方，轻量，回调简单	普通项目、入门推荐
AndPermission	API 链式，功能强大	中大型项目，UI 提示丰富
RxPermissions	RxJava 响应式	已经用 RxJava 的项目最方便

把pt文件放到assets目录下面

sourceSets {
        main {
            assets.srcDirs = ['src/main/assets']
        }
    }

    
implementation 'org.pytorch:pytorch_android:1.12.1'  // PyTorch Android
implementation 'org.pytorch:pytorch_android_torchvision:1.12.1'  // 包含TorchVision


public static void example(Context context) throws IOException {
        int airType = 0;
        int M = 3000;
        int inputSize = 1;
        int maxRows = 3000; // CSV 数据总行数
        String csvFilename = "air_data.csv";

        // PT 模型路径
        String ptModelPath = context.getFilesDir() + "/air_model_1.pt";
        copyAssetToInternal(context,"air_model_1.pt", ptModelPath);

        // 1. 读取 CSV
        float[][] data = readCSVFromAssets(context, csvFilename, airType, maxRows);
        int length = data.length;

        // 2. 构造 trainX 和 x
        float[][] trainX = new float[M][inputSize];
        float[][] x = new float[length][inputSize];
        for (int i = 0; i < M; i++) trainX[i][0] = data[i][0];
        for (int i = 0; i < length; i++) x[i][0] = data[i][0];

        // 3. 设置训练时 mean/std（必须和训练时一致）
        float trainMean = 12.90614f;
        float trainStd = 8.80730f;

        // 4. 加载 PT 模型
        Module module = Module.load(ptModelPath);
        if (module != null) {
            Log.d("Torch", "Module 非空，说明加载成功");
        } else {
            Log.e("Torch", "Module 是 null，加载失败");
        }

//        float[][] out = predict(module, trainX, x, trainStd, trainMean, inputSize, length, M);

//        getWarn(module,data,0,3000,inputSize,length,10,3.0f,3.0f,trainMean,trainStd);
        // 设置阈值 0.1，可根据训练数据调整
//        boolean[] abnormal = detectAnomalies(out, x, 0.1f);
//        Result result = new Result(out, abnormal);
        // 5. 调用模型 forward

        float[][] data2 = readCSVFromAssetsAll(context, csvFilename, maxRows);

//        getPtData(data2,module,context);
//        getTestPt(module);
//        Object[] results = DateutilsGetDataTest.getDataTest(context,inputSize,60,csvFilename,3);//测试数据
        Object[] results = DateutilsGetDataTest.getDataAndroidWithLog(context,inputSize,60,csvFilename,1);//真实数据
        getVcsGetDatePt(results,module);
    }

    //获取cvs数据，归一化 反归一化
    public static void getVcsGetDatePt(Object[] results,Module module){
        int length = 3120;
        int inputsize = 1;


        Tensor testXTensor = (Tensor) results[0];
        Tensor testYTensor = (Tensor) results[1];
        int lengethtensor = (int) results[2];
        float mean= (float) results[3];
        float std  = (float) results[4];


        Tensor trainMeanTensor = Tensor.fromBlob(new float[]{mean}, new long[]{1});
        Tensor trainStdTensor = Tensor.fromBlob(new float[]{std}, new long[]{1});
        Tensor inputSizeTensor = Tensor.fromBlob(new long[]{inputsize}, new long[]{1});
        Tensor lengthTensor = Tensor.fromBlob(new long[]{lengethtensor}, new long[]{1});

        IValue[] inputs = new IValue[]{
                IValue.from(testXTensor),
                IValue.from(testYTensor),
                IValue.from(trainStdTensor),
                IValue.from(trainMeanTensor),
                IValue.from(inputSizeTensor),  // int
                IValue.from(lengthTensor)      // int
        };


        IValue output = module.forward(inputs);

        // 解析输出 (模型返回 Tuple(Tensor, Tensor))
        Tensor outTensor = output.toTuple()[0].toTensor();
        float[] outArray = outTensor.getDataAsFloatArray();

        // 打印前5行
        Log.i("xqm", "PT model output 前5行:");
        for (int i = 0; i < Math.min(5, length); i++) {
            Log.i("xqm", String.valueOf(outArray[i]));
        }


        IValue[] outputs = output.toTuple();
        Tensor firstOutput = outputs[0].toTensor();  // 第一个预测结果 Tensor
        Tensor secondOutput = outputs[1].toTensor(); // 第二个 Tensor，如果需要
        firstFifity(firstOutput,mean,std);

        float[] outFlat = outTensor.getDataAsFloatArray();

        float[][] out_o = new float[length][inputsize];
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < inputsize; j++) {
                out_o[i][j] = outFlat[i * inputsize + j] * std + mean;
            }
        }

        for (int i = 0; i < Math.min(5, length); i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < inputsize; j++) {
                sb.append(out_o[i][j]).append(",");
            }
            Log.d("TorchOut", "xqm  Android output line " + i + ": " + sb.toString());
        }


    }



    public static void firstFifity(Tensor outputTensor, float trainMean, float trainStd){
        float[] outputArray = outputTensor.getDataAsFloatArray();

        // 反归一化
        float[] realOutput = new float[outputArray.length];
        for (int i = 0; i < outputArray.length; i++) {
            realOutput[i] = outputArray[i] * trainStd + trainMean;
        }

        // 打印前50个预测值
        int printCount = Math.min(50, realOutput.length);
        for (int i = 0; i < printCount; i++) {
            Log.d("InferenceOutput", "Pred[" + i + "] = " + realOutput[i]);
        }
    }

    // 从 assets 拷贝模型到内部存储
    public static void copyAssetToInternal(Context context,String assetName, String destPath) {
        try {
            InputStream is = context.getAssets().open(assetName);
            File outFile = new File(destPath);
            FileOutputStream os = new FileOutputStream(outFile);
            byte[] buffer = new byte[1024];
            int read;
            while ((read = is.read(buffer)) != -1) {
                os.write(buffer, 0, read);
            }
            is.close();
            os.flush();
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }



	//读取csv列表数据，并组装成pt需要的数据返回
    public static Object[] getDataAndroidWithLog(Context context,int inputsize, int M,  String assetFileName, int airType) throws IOException {
        // 1. 读取 assets 目录下 CSV
        AssetManager assetManager = context.getAssets();
        InputStream is = assetManager.open(assetFileName);
        BufferedReader br = new BufferedReader(new InputStreamReader(is));

        br.readLine(); // 第一行是表头，跳过
        List<Float> dataList = new ArrayList<>();
        String line;
        while ((line = br.readLine()) != null) {
            String[] tokens = line.split(",");
            dataList.add(Float.parseFloat(tokens[airType]));
        }
        br.close();

        dataList = new ArrayList<>(dataList.subList(0, Math.min(3120, dataList.size())));//后续删掉

        int totalLength = dataList.size();
        float[] data = new float[totalLength];
        for (int i = 0; i < totalLength; i++) data[i] = dataList.get(i);

        Log.d("xqm", "总数据: " + totalLength);

        Log.d("xqm", "原始数据前10条: " + Arrays.toString(Arrays.copyOf(data, Math.min(10, totalLength))));

        // 2. 均值和标准差
        float sum = 0f;
        for (float v : data) sum += v;
        float mean = sum / totalLength;

        float std = 0f;
        for (float v : data) std += (v - mean) * (v - mean);
        std = (float)Math.sqrt(std / totalLength);

        Log.d("xqm", "mean: " + mean + ", std: " + std);

        // 3. 归一化
        float[] normalizedData = new float[totalLength];
        if (std != 0f) {
            for (int i = 0; i < totalLength; i++) normalizedData[i] = (data[i] - mean) / std;
        } else {
            for (int i = 0; i < totalLength; i++) normalizedData[i] = data[i] - mean;
        }
        Log.d("xqm", "归一化后前10条: " + Arrays.toString(Arrays.copyOf(normalizedData, Math.min(10, totalLength))));

        // 4. Tensor 处理
        int lengthTest = totalLength; // 全部数据作为测试集
        float[] testY = new float[lengthTest * inputsize];
        float[] testXFlat = new float[lengthTest * inputsize];

        for (int i = 0; i < lengthTest; i++) {
            for (int j = 0; j < inputsize; j++) {
                // testY 是反归一化
                if (std != 0f) testY[i * inputsize + j] = normalizedData[i] * std + mean;
                else testY[i * inputsize + j] = normalizedData[i] + mean;

                // testXFlat 是归一化
                if (std != 0f) testXFlat[i * inputsize + j] = (testY[i * inputsize + j] - mean) / std;
                else testXFlat[i * inputsize + j] = testY[i * inputsize + j] - mean;
            }
        }

        Log.d("xqm", "testY 前10条: " + Arrays.toString(Arrays.copyOf(testY, Math.min(10, testY.length))));
        Log.d("xqm", "testXFlat 前10条: " + Arrays.toString(Arrays.copyOf(testXFlat, Math.min(10, testXFlat.length))));

        // 5. 保证 reshape 可整除
        int newLengthTest = (lengthTest / M) * M;
        float[] testXFlatTrim = Arrays.copyOf(testXFlat, newLengthTest * inputsize);

        Tensor testXTensor = Tensor.fromBlob(testXFlatTrim, new long[]{M, newLengthTest / M, inputsize});
        Tensor testYTensor = Tensor.fromBlob(testY, new long[]{1,lengthTest, inputsize});

        return new Object[]{testXTensor, testYTensor, lengthTest, mean, std};
    }
    
    

张量可以理解为 多维数组：

0 维张量 → 一个标量（单个数字，例如 5）

1 维张量 → 一个向量（数组，例如 [1, 2, 3]）

2 维张量 → 一个矩阵（表格，例如 [[1,2],[3,4]]）

3 维张量 → 例如一张彩色图片 [高度, 宽度, 通道数]

4 维张量 → 一批彩色图片 [批大小, 高度, 宽度, 通道数]

张量的 形状 就是它的 维度大小，告诉我们张量里有多少数据。

例子：

import torch

x = torch.randn(1, 3, 224, 224)  # 随机生成一个张量
print(x.shape)


输出：

torch.Size([1, 3, 224, 224])


解释：

1 → 批量大小（batch size），表示有 1 张图片

3 → 通道数（RGB 三个通道）

224, 224 → 图片的高度和宽度

1. Handler + Runnable（最常用，简单）
private Handler handler = new Handler(Looper.getMainLooper());
private Runnable batteryRunnable = new Runnable() {
    @Override
    public void run() {
        updateBattery(context); // 查询电池
        handler.postDelayed(this, 1000); // 每秒重复
    }
};

public void start() {
    handler.post(batteryRunnable);
}

public void stop() {
    handler.removeCallbacks(batteryRunnable);
}
优点：简单、直接、在主线程可操作 UI。
缺点：任务在主线程执行，不适合耗时操作


2. ScheduledExecutorService（后台线程）
private ScheduledExecutorService scheduler;

public void start() {
    scheduler = Executors.newSingleThreadScheduledExecutor();
    scheduler.scheduleAtFixedRate(() -> updateBattery(context), 0, 1, TimeUnit.SECONDS);
}

public void stop() {
    if (scheduler != null) {
        scheduler.shutdownNow();
        scheduler = null;
    }
}

优点：在后台线程，不会阻塞主线程，可扩展。
缺点：操作 UI 需要 Handler 或 runOnUiThread()。

3. RxJava（如果项目已经有 Rx）

disposable = Observable.interval(0, 1, TimeUnit.SECONDS)
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(tick -> updateBattery(context));

优点：易于管理订阅和取消，UI 操作简单。
缺点：依赖 RxJava。 

1. build.gradle 依赖
确保你的 app 模块的 build.gradle（通常是 app/build.gradle）包含以下依赖：

// Room 依赖   分为java和kotlin
//java的
def room_version = "2.5.2"
implementation "androidx.room:room-runtime:$room_version"
annotationProcessor "androidx.room:room-compiler:$room_version" 


 

//kotlin必须 kapt
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    id 'kotlin-kapt'
}

    implementation "androidx.room:room-runtime:$room_version"
    implementation "androidx.room:room-ktx:$room_version"  // 可选，支持协程
    kapt "androidx.room:room-compiler:$room_version"       // Kotlin 必须用 kapt



    


import androidx.room.Entity;
import androidx.room.PrimaryKey;

@Entity
public class User {
    @PrimaryKey(autoGenerate = true)
    public int userId;

    public String name;
    public int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

import androidx.room.Dao;
import androidx.room.Insert;
import androidx.room.Query;
import java.util.List;

@Dao
public interface UserDao {

    @Insert
    void insertUser(User user);

    @Query("SELECT * FROM User")
    List<User> getAllUsers();
}

import androidx.room.Database;
import androidx.room.RoomDatabase;

@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}

// 在Activity或Application里初始化
AppDatabase db = Room.databaseBuilder(getApplicationContext(),
        AppDatabase.class, "my-database").build();

        // 插入数据（注意不能在主线程，建议放到子线程）
new Thread(() -> {
    UserDao userDao = db.userDao();
    BookDao bookDao = db.bookDao();

    User user = new User("Alice", 30);
    userDao.insertUser(user);

    Book book = new Book("Android Development", 1); // 这里1为userId，需要先获取
    bookDao.insertBook(book);

    List<User> users = userDao.getAllUsers();
    List<Book> books = bookDao.getBooksByUserId(1);

    // 处理结果
}).start();



import android.app.Application;
import androidx.room.Room;

public class MyApp extends Application {

    private static AppDatabase database;

    @Override
    public void onCreate() {
        super.onCreate();
        database = Room.databaseBuilder(getApplicationContext(),
                AppDatabase.class, "my-database")
                .build();
    }

    // 对外暴露获取数据库实例的方法
    public static AppDatabase getDatabase() {
        return database;
    }
}

其他页面调用
AppDatabase db = MyApp.getDatabase();
UserDao userDao = db.userDao();

		  try (InputStream is = context.getAssets().open(filePath)) {
                List<AirPortNoFlyEntity> points = parseExcelPoints2(is);
                addMarkersToMap(baiduMap,points,RADIUS_KM);

            } catch (Exception e) {
                e.printStackTrace();
            }


private  List<AirPortNoFlyEntity> parseExcelPoints2(InputStream is) throws Exception {
        try {
            // 从 assets 读取 JSON 文件
            byte[] buffer = new byte[is.available()];
            is.read(buffer);
            is.close();
            String json = new String(buffer, StandardCharsets.UTF_8);

            // 使用 Gson 解析为 List<Point>
            return new Gson().fromJson(json, new TypeToken<List<AirPortNoFlyEntity>>() {}.getType());
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
}