# Orchestra

**Repository Path**: giteewfy/orchestra

## Basic Information

- **Project Name**: Orchestra
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-03-19
- **Last Updated**: 2025-03-21

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

> gitee: https://gitee.com/giteewfy/orchestra  <br>

#  OrchestraCore
一个多线程加载任务依赖框架，借用交响乐（Orchestra）指挥隐喻，强调框架对多线程任务的精准协调能力。

# 基本使用
```
        val taskGraph = TaskGraph()
        taskGraph.bindToLifecycle(lifecycle)
        // 定义任务
        val task0: TaskGraph.Task = object : TaskGraph.Task {

            override val id: String = "0"
            override var priority: Int = 0
            override fun execute() {
                LogUtils.logV(msg = "Task 0 execute")
                LogUtils.logV(msg = "Task 0 end")
            }
        }

        val task1: TaskGraph.Task = object : TaskGraph.Task {

            override val id: String get() = "1"
            override var priority: Int = 0

            override fun execute() {
                LogUtils.logV(msg = "Task 1 execute")
                LogUtils.logV(msg = "Task 1 end")
            }
        }
        val task2: TaskGraph.Task = object : TaskGraph.Task {
            override val id: String get() = "2"
            override var priority: Int = 0
            override fun execute() {
                LogUtils.logV(msg = "Task 2 execute")
                LogUtils.logV(msg = "Task 2 end")
            }
        }

        val task3: TaskGraph.Task = object : TaskGraph.Task {
            override val id: String get() = "3"
            override var priority: Int = 0
            override fun execute() {
                LogUtils.logV(msg = "Task 3 execute")
                Thread.sleep(10 * 1000L)
                LogUtils.logV(msg = "Task 3 end")
            }
        }
        val task4: TaskGraph.Task = object : TaskGraph.Task {
            override val id: String get() = "4"
            override var priority: Int = 0
            override fun execute() {
                LogUtils.logV(msg = "Task 4 execute")
                Thread.sleep(20 * 1000L)
                LogUtils.logV(msg = "Task 4 end")
            }
        }
        val task5: TaskGraph.Task = object : TaskGraph.Task {
            override val id: String get() = "5"
            override var priority: Int = 0
            override fun execute() {
                LogUtils.logV(msg = "Task 5 execute")
                LogUtils.logV(msg = "Task 5 end")
            }
        }
        // 添加任务和依赖
        taskGraph.addTask(task0)
        taskGraph.addTask(task1)
        taskGraph.addTask(task2)
        taskGraph.addTask(task3)
        taskGraph.addTask(task4)
        taskGraph.addTask(task5)
        // 添加依赖 方式一
//        taskGraph.addDependency("5", "3")
//        taskGraph.addDependency("5", "4")
//
//        taskGraph.addDependency("3", "0")
//        taskGraph.addDependency("3", "1")
//
//        taskGraph.addDependency("4", "1")
//        taskGraph.addDependency("4", "2")
//
//        // 添加依赖 方式二 推荐
//        taskGraph.addDependency("5", listOf("3", "4"))
//        taskGraph.addDependency("3", listOf("0", "1"))
//        taskGraph.addDependency("4", listOf("1", "2"))

        // 添加依赖 方式三 推荐
        taskGraph.configureDependencies {
            "5" dependsOn listOf("3", "4")
            "3" dependsOn listOf("0", "1")
            "4" dependsOn listOf("1", "2")
        }


        // 错误监听
        taskGraph.setOnErrorListener(object : TaskGraph.OnErrorListener {
            override fun onError(task: TaskGraph.Task, cause: Throwable) {
                LogUtils.logV(msg = "TaskGraph Task failed:id = ${task.id} cause = $cause")
            }
        })
        // 启动执行
        LogUtils.logV(msg = "generateDotGraph = ${taskGraph.generateDotGraph()}")
        taskGraph.start()
```

##  1.0.0 版本

## 计划
### 依赖关系添加
### 依赖关系可以任务分组管理
### 动态依赖推导
### 依赖关系验证增强
### 可视化配置接口
### 动态依赖调整
### 调度算法优化为事件驱动