# ExecutorProvider

**Repository Path**: yupfeg/ExecutorProvider

## Basic Information

- **Project Name**: ExecutorProvider
- **Description**: 自用线程池库，收敛项目的线程调用，避免线程资源浪费
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2022-01-16
- **Last Updated**: 2022-05-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# ExecutorProvider

线程池库，收敛项目线程调用，统一线程池，避免资源浪费

提供两类线程池

- CPU密集型线程池 ：处理相对耗时的异步任务，需要控制最大并发数
- IO密集型线程池 ： 处理占用时间短但频率比较高的任务，实际并发量比较小且需要快速反应

## 依赖方式
[![](https://jitpack.io/v/com.gitee.yupfeg/ExecutorProvider.svg)](https://jitpack.io/#com.gitee.yupfeg/ExecutorProvider)
```groovy
//root build.gradle
allprojects {
    repositories {
        maven { url 'https://jitpack.io' }
    }
}

//module build.gradle
dependencies {
    implementation 'com.gitee.yupfeg:ExecutorProvider:1.0.2'
}
```

## 使用方式 

默认会创建IO密集型和CPU密集型的线程池

``` kotlin
ExecutorProvider.getInstance().ioExecutor.execute{
    //执行IO密集型任务
}

ExecutorProvider.getInstance().cpuExecutor.execute{
    //执行CPU密集型任务
}
```

如果需要修改线程池配置，需要在调用`ExecutorProvider.getInstance()`前，调用`ExecutorProvider.prepare()`函数，实现工厂类`ExecutorFactory`来设置如何创建这两种线程池。

``` kotlin
//配置线程池，只能执行一次，后续无效且报错
ExecutorProvider.prepare(object : ExecutorFactory {
    override fun createIOThreadPool(): ExecutorService {
		//IO密集型线程池
    }

    override fun createCPUThreadPool(): ExecutorService {
        //CPU密集型线程池
    }

})
//配置完成后再调用获取线程池
ExecutorProvider.getInstance()
```

- 简化线程池构建

提供了`ThreadPoolBuilder`类以Build模式来简化线程池构建，内部提供默认配置的线程池配置。

``` kotlin

fun createDefaultIOBuilder() : ThreadPoolBuilder{
    return ThreadPoolBuilder().apply {
        corePoolSize = 0
        maxPoolSize = Int.MAX_VALUE
        keepAliveTime = 30
        blockingQueue = SynchronousQueue()
        threadFactory = DefaultThreadFactory(
            prefix = "io", isDaemon = false
        )
    }
}

fun createDefaultCpuBuilder() : ThreadPoolBuilder{
    return ThreadPoolBuilder().apply {
        corePoolSize = CPU_CORE_POOL_SIZE
        maxPoolSize = CPU_MAX_POOL_SIZE
        keepAliveTime = CPU_KEEP_ALIVE_SECONDS.toLong()
        //允许核心线程超时销毁
        isCoreThreadTimeOut = true
        blockingQueue = LinkedBlockingQueue()
        threadFactory = DefaultThreadFactory(
            prefix = "cpu", isDaemon = false
        )
        rejectedHandler = RejectedExecutionHandler { r, _ ->
            //如果cpu线程池满后，交由新开的无界线程池执行，理论上来说不会执行
			Executors.newCachedThreadPool().execute(r)
        }
    }
}
```



- Kotlin-DSL支持

如果使用`Kotlin`，提供了利用`Kotlin`高阶函数的顶层函数，快捷配置线程池`ThreadPoolBuilder`、线程池工厂`ExecutorFactory`。灵活提供了在原有配置基础上修改的顶层函数

``` kotlin
prepareExecutor { //函数返回ExecutorFactory
    //1. 构建默认配置的CPU密集型线程池，自定义IO密集型线程池
    buildDefCPUThreadPoolFactory{
        ioThreadPoolBuilder{
            //在默认io线程池配置基础上，修改对应配置
        }
    }
    
    //2. 构建默认配置的IO密集型线程池，自定义CPU密集型线程池
    buildDefIOThreadPoolFactory{
        cpuThreadPoolBuilder{
            //在默认cpu线程池配置基础上，修改对应配置
        }
    }
    //3. 构建线程池工厂类
    object : ExecutorFactory {
        override fun createIOThreadPool(): ExecutorService {
            //IO密集型线程池
            threadPoolBuilder{
                //配置线程池
            }.build()
        }

        override fun createCPUThreadPool(): ExecutorService {
            //CPU密集型线程池
            threadPoolBuilder{
                //配置线程池
            }.build()
        }
	}
}
```