# EnergyThread

**Repository Path**: cjf_90/EnergyThread

## Basic Information

- **Project Name**: EnergyThread
- **Description**: 线程相关封装
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-02-02
- **Last Updated**: 2025-12-26

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# EnergyThread

EnergyThread 是一个灵活的并发任务编排框架，适用于 Android 和 Java 平台。它提供了对任意多线程并行、串行、阻塞、依赖、回调等场景的支持，能够满足复杂的任务编排需求。

## 特点

- **任意编排**：支持任意复杂的任务依赖关系，包括串行、并行、阻塞等待等。
- **回调机制**：为每个任务提供执行结果的回调，支持执行成功、失败、超时的处理。
- **任务依赖**：支持任务之间的强依赖和弱依赖关系，可以指定依赖任务是否必须执行完毕。
- **结果传递**：后续任务可以以前置任务的结果作为入参，实现任务间的数据传递。
- **超时控制**：支持设置全组任务的超时时间，控制整个任务组的执行时间。
- **高性能**：全程无锁设计，线程利用率高，创建线程量少。

## 基本组件

### Worker

Worker 是最小的任务执行单元，通常是一个网络调用或一段耗时操作。支持泛型入参和出参类型。

```java
public interface IWorker<T, V> {
    V action(T object, Map<String, WorkerWrapper> allWrappers);
    V defaultValue();
}
```

### Callback

Callback 是每个任务执行完毕后的回调接口，提供任务开始和结束的回调方法。

```java
public interface ICallback<T, V> {
    void begin();
    void result(boolean success, T param, WorkResult<V> workResult);
}
```

### WorkerWrapper

WorkerWrapper 是最小的调度单元，组合了 Worker 和 Callback。通过编排 WorkerWrapper 之间的关系，可以实现任务的顺序控制。

```java
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
        .worker(w)
        .callback(w)
        .param("0")
        .build();
```

## 使用示例

### 三个任务并行执行

```java
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();

WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
        .worker(w2)
        .callback(w2)
        .param("2")
        .build();

WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
        .worker(w1)
        .callback(w1)
        .param("1")
        .build();

WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
        .worker(w)
        .callback(w)
        .param("0")
        .build();

Async.beginWork(1500, workerWrapper, workerWrapper1, workerWrapper2);
Async.shutDown();
```

### 任务串行执行

```java
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
ParWorker3 w3 = new ParWorker3();

WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
        .worker(w3)
        .callback(w3)
        .param("3")
        .build();

WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
        .worker(w2)
        .callback(w2)
        .param("2")
        .next(workerWrapper3)
        .build();

WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
        .worker(w1)
        .callback(w1)
        .param("1")
        .next(workerWrapper3)
        .build();

WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
        .worker(w)
        .callback(w)
        .param("0")
        .next(workerWrapper1, workerWrapper2)
        .build();

Async.beginWork(3100, workerWrapper);
Async.shutDown();
```

## 安装

在项目根目录的 `build.gradle` 中添加仓库：

```groovy
allprojects {
    repositories {
        maven { url 'https://jitpack.io' }
    }
}
```

在模块的 `build.gradle` 中添加依赖：

```groovy
implementation 'com.gitee.cjf_90:EnergyThread:0.0.8'
implementation 'net.sourceforge.streamsupport:android-retrofuture:1.7.4'
```

## 许可证

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.