讲师中心 微信公众号
首页
文章
后端开发 web前端 数据库 开发工具 php框架 常见问题 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 自媒体 新闻
专题
后端开发 web前端 数据库 开发工具 php框架 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 新闻
AI工具
AI 聊天问答 Agent智能体 AI 文本写作 AI 绘画作图 AI 设计工具 AI 视频创作 AI 音频制作 AI 办公学习 AI 编程开发 Prompt指令
学习
大前端 后端开发 数据库 移动端 运维开发 计算机基础
编程手册
大前端 后端开发 数据库 移动端 运维开发 计算机基础
下载
js特效 网站源码 工具下载 类库下载 网站素材 学习资源 插件扩展 手机游戏
最近更新
当前位置：首页 > Java > java教程 >

正文

0

0

如何使用Java实现多线程程序？

PHPz

PHPz

发布时间：2023-04-23 09:19:06

|

1490人浏览过

|

来源于亿速云

转载

1.多线程执行任务类

package com.visy.threadpool;

import com.visy.executor.ExecutorFactory;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ThreadPoolConfig {
    private TheadPoolProperties theadPoolProperties;
    private ThreadPoolExecutor executor;
    private ThreadPoolExecutor executorChild;

    public ThreadPoolConfig(TheadPoolProperties theadPoolProperties) {
        this.theadPoolProperties = theadPoolProperties;
        this.executor = ExecutorFactory.getInstance().getThreadPoolExecutor("ThreadPoolConfig-service", theadPoolProperties.getQueueSize(), theadPoolProperties.getCoreThreadNum(), theadPoolProperties.getMaxPoolSize());
        this.executorChild = ExecutorFactory.getInstance().getThreadPoolExecutor("ThreadPoolConfig-service-child", theadPoolProperties.getQueueSize(), theadPoolProperties.getCoreThreadNum(), theadPoolProperties.getMaxPoolSize());
    }

    public  List doConcurrentTask(List> taskList, ThreadPoolExecutor... executorChilds) {
        if (taskList != null && !taskList.isEmpty()) {
            List resultList = new ArrayList();
            List futureList = null;

            try {
                if (this.executor.getQueue().size() >= this.theadPoolProperties.getQueueSize()) {
                    throw new RuntimeException("queue size bigger than 100, now size is " + this.executor.getQueue().size());
                }

                if (executorChilds != null && executorChilds.length > 0 && executorChilds[0] != null) {
                    futureList = executorChilds[0].invokeAll(taskList);
                } else {
                    futureList = this.executor.invokeAll(taskList, (long)this.theadPoolProperties.getTimeOut(), TimeUnit.SECONDS);
                }
            } catch (InterruptedException var6) {
                var6.printStackTrace();
            }

            this.doFutureList(resultList, futureList);
            return resultList;
        } else {
            return null;
        }
    }

     void doFutureList(List resultList, List> futureList) {
        if (futureList != null) {
            Iterator var3 = futureList.iterator();

            while(var3.hasNext()) {
                Future future = (Future)var3.next();

                try {
                    resultList.add(future.get());
                } catch (ExecutionException | InterruptedException var6) {
                    var6.printStackTrace();
                }
            }
        }

    }

    public  void doVoidConcurrentTask(List> taskList) {
        if (taskList != null && !taskList.isEmpty()) {
            Iterator var2 = taskList.iterator();

            while(var2.hasNext()) {
                Callable call = (Callable)var2.next();
                this.executor.submit(call);
            }

        }
    }

    public TheadPoolProperties getTheadPoolProperties() {
        return this.theadPoolProperties;
    }

    public ThreadPoolExecutor getExecutor() {
        return this.executor;
    }

    public ThreadPoolExecutor getExecutorChild() {
        return this.executorChild;
    }

    public void setTheadPoolProperties(TheadPoolProperties theadPoolProperties) {
        this.theadPoolProperties = theadPoolProperties;
    }

    public void setExecutor(ThreadPoolExecutor executor) {
        this.executor = executor;
    }

    public void setExecutorChild(ThreadPoolExecutor executorChild) {
        this.executorChild = executorChild;
    }

    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof ThreadPoolConfig)) {
            return false;
        } else {
            ThreadPoolConfig other = (ThreadPoolConfig)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                label47: {
                    Object this$theadPoolProperties = this.getTheadPoolProperties();
                    Object other$theadPoolProperties = other.getTheadPoolProperties();
                    if (this$theadPoolProperties == null) {
                        if (other$theadPoolProperties == null) {
                            break label47;
                        }
                    } else if (this$theadPoolProperties.equals(other$theadPoolProperties)) {
                        break label47;
                    }

                    return false;
                }

                Object this$executor = this.getExecutor();
                Object other$executor = other.getExecutor();
                if (this$executor == null) {
                    if (other$executor != null) {
                        return false;
                    }
                } else if (!this$executor.equals(other$executor)) {
                    return false;
                }

                Object this$executorChild = this.getExecutorChild();
                Object other$executorChild = other.getExecutorChild();
                if (this$executorChild == null) {
                    if (other$executorChild != null) {
                        return false;
                    }
                } else if (!this$executorChild.equals(other$executorChild)) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(Object other) {
        return other instanceof ThreadPoolConfig;
    }

    public int hashCode() {
        int PRIME = true;
        int result = 1;
        Object $theadPoolProperties = this.getTheadPoolProperties();
        int result = result * 59 + ($theadPoolProperties == null ? 43 : $theadPoolProperties.hashCode());
        Object $executor = this.getExecutor();
        result = result * 59 + ($executor == null ? 43 : $executor.hashCode());
        Object $executorChild = this.getExecutorChild();
        result = result * 59 + ($executorChild == null ? 43 : $executorChild.hashCode());
        return result;
    }

    public String toString() {
        return "ThreadPoolConfig(theadPoolProperties=" + this.getTheadPoolProperties() + ", executor=" + this.getExecutor() + ", executorChild=" + this.getExecutorChild() + ")";
    }
}

2.执行器工厂类

package com.visy.executor;

import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExecutorFactory {
    private static final Logger logger = LoggerFactory.getLogger(ExecutorFactory.class);
    private static final Map threadPoolExecutorMap = new ConcurrentHashMap();
    private static final int DEFAULT_QUEUE_SIZE = 1000;
    private static final String DEFAULT_EXECUTOR_NAME = "default-executor";
    private static final int MAX_THREAD_NUM = 100;
    private static final int CORE_THREAD_NUM = 1;
    private static volatile ExecutorFactory instance;

    private ExecutorFactory() {
    }

    public static ExecutorFactory getInstance() {
        if (instance == null) {
            Class var0 = ExecutorFactory.class;
            synchronized(ExecutorFactory.class) {
                if (instance == null) {
                    instance = new ExecutorFactory();
                }
            }
        }

        return instance;
    }

    public ThreadPoolExecutor getThreadPoolExecutorByName(String name) {
        return (ThreadPoolExecutor)threadPoolExecutorMap.get(name);
    }

    public static Map getThreadPoolExecutorMap() {
        return threadPoolExecutorMap;
    }

    public ThreadPoolExecutor getThreadPoolExecutor(String threadPoolExecutorName, int queueSize, int coreThreadNum, int maxPoolSize) {
        if (StringUtils.isBlank(threadPoolExecutorName)) {
            throw new IllegalArgumentException("thread name empty");
        } else {
            if (!threadPoolExecutorMap.containsKey(threadPoolExecutorName)) {
                Class var5 = ExecutorFactory.class;
                synchronized(ExecutorFactory.class) {
                    if (!threadPoolExecutorMap.containsKey(threadPoolExecutorName)) {
                        ThreadPoolExecutor executor = (new ThreadPool(coreThreadNum, maxPoolSize, 30L, queueSize, threadPoolExecutorName)).getExecutor();
                        threadPoolExecutorMap.put(threadPoolExecutorName, executor);
                        logger.info("thread name: {} executor created", threadPoolExecutorName);
                    }
                }
            }

            return (ThreadPoolExecutor)threadPoolExecutorMap.get(threadPoolExecutorName);
        }
    }

    public  void submit(T t) {
        ThreadPoolExecutor defaultExecutor = this.getThreadPoolExecutor();
        defaultExecutor.submit(t);
    }

    public  void submit(String poolName, T t) {
        ThreadPoolExecutor executor = this.getThreadPoolExecutorByName(poolName);
        if (executor == null) {
            logger.error("thread name: {} executor not exist.", poolName);
            throw new IllegalArgumentException("thread name:" + poolName + " executor not exist.");
        } else {
            executor.submit(t);
        }
    }

    public > Future submit(T t) {
        ThreadPoolExecutor defaultExecutor = this.getThreadPoolExecutor();
        return defaultExecutor.submit(t);
    }

    public > Future submit(String poolName, T t) {
        ThreadPoolExecutor executor = this.getThreadPoolExecutorByName(poolName);
        if (executor == null) {
            logger.error("thread poolName: {} executor not exist.", poolName);
            throw new IllegalArgumentException("thread poolName:" + poolName + " executor not exist.");
        } else {
            return executor.submit(t);
        }
    }

    public ThreadPoolExecutor getThreadPoolExecutor() {
        return this.getThreadPoolExecutor("default-executor", 1000, 1, 100);
    }
}
3.多线程配置类
package com.visy.threadpool;

import javax.validation.constraints.NotNull;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.annotation.Validated;

@Validated
@Configuration
@ConfigurationProperties(prefix = "visy.threadpool")
public class TheadPoolProperties {
    // 执行并行任务时，等待多久时间超时(单位：秒)
    @NotNull
    private Integer timeOut;
    // 队列大小
    @NotNull
    private Integer queueSize; 
    // 核心线程数量
    @NotNull
    private Integer coreThreadNum;
    // 线程池最大线程数量
    @NotNull
    private Integer maxPoolSize;
    // 并行执行每组大小
    private Integer groupSize = 20;

    public TheadPoolProperties() {
    }

    public Integer getTimeOut() {
        return this.timeOut;
    }

    public Integer getQueueSize() {
        return this.queueSize;
    }

    public Integer getCoreThreadNum() {
        return this.coreThreadNum;
    }

    public Integer getMaxPoolSize() {
        return this.maxPoolSize;
    }

    public Integer getGroupSize() {
        return this.groupSize;
    }

    public void setTimeOut(Integer timeOut) {
        this.timeOut = timeOut;
    }

    public void setQueueSize(Integer queueSize) {
        this.queueSize = queueSize;
    }

    public void setCoreThreadNum(Integer coreThreadNum) {
        this.coreThreadNum = coreThreadNum;
    }

    public void setMaxPoolSize(Integer maxPoolSize) {
        this.maxPoolSize = maxPoolSize;
    }

    public void setGroupSize(Integer groupSize) {
        this.groupSize = groupSize;
    }

    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof TheadPoolProperties)) {
            return false;
        } else {
            TheadPoolProperties other = (TheadPoolProperties)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                label71: {
                    Object this$timeOut = this.getTimeOut();
                    Object other$timeOut = other.getTimeOut();
                    if (this$timeOut == null) {
                        if (other$timeOut == null) {
                            break label71;
                        }
                    } else if (this$timeOut.equals(other$timeOut)) {
                        break label71;
                    }

                    return false;
                }

                Object this$queueSize = this.getQueueSize();
                Object other$queueSize = other.getQueueSize();
                if (this$queueSize == null) {
                    if (other$queueSize != null) {
                        return false;
                    }
                } else if (!this$queueSize.equals(other$queueSize)) {
                    return false;
                }

                label57: {
                    Object this$coreThreadNum = this.getCoreThreadNum();
                    Object other$coreThreadNum = other.getCoreThreadNum();
                    if (this$coreThreadNum == null) {
                        if (other$coreThreadNum == null) {
                            break label57;
                        }
                    } else if (this$coreThreadNum.equals(other$coreThreadNum)) {
                        break label57;
                    }

                    return false;
                }

                Object this$maxPoolSize = this.getMaxPoolSize();
                Object other$maxPoolSize = other.getMaxPoolSize();
                if (this$maxPoolSize == null) {
                    if (other$maxPoolSize != null) {
                        return false;
                    }
                } else if (!this$maxPoolSize.equals(other$maxPoolSize)) {
                    return false;
                }

                Object this$groupSize = this.getGroupSize();
                Object other$groupSize = other.getGroupSize();
                if (this$groupSize == null) {
                    if (other$groupSize == null) {
                        return true;
                    }
                } else if (this$groupSize.equals(other$groupSize)) {
                    return true;
                }

                return false;
            }
        }
    }

    protected boolean canEqual(Object other) {
        return other instanceof TheadPoolProperties;
    }

    public int hashCode() {
        int PRIME = true;
        int result = 1;
        Object $timeOut = this.getTimeOut();
        int result = result * 59 + ($timeOut == null ? 43 : $timeOut.hashCode());
        Object $queueSize = this.getQueueSize();
        result = result * 59 + ($queueSize == null ? 43 : $queueSize.hashCode());
        Object $coreThreadNum = this.getCoreThreadNum();
        result = result * 59 + ($coreThreadNum == null ? 43 : $coreThreadNum.hashCode());
        Object $maxPoolSize = this.getMaxPoolSize();
        result = result * 59 + ($maxPoolSize == null ? 43 : $maxPoolSize.hashCode());
        Object $groupSize = this.getGroupSize();
        result = result * 59 + ($groupSize == null ? 43 : $groupSize.hashCode());
        return result;
    }

    public String toString() {
        return "TheadPoolProperties(timeOut=" + this.getTimeOut() + ", queueSize=" + this.getQueueSize() + ", coreThreadNum=" + this.getCoreThreadNum() + ", maxPoolSize=" + this.getMaxPoolSize() + ", groupSize=" + this.getGroupSize() + ")";
    }
}
4.列表拆分工具类
package com.visy.utils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.jar.Attributes;

/**
 * 列表或数组按指定大小分组,用于批量取一部分数据循环处理
 *
 */
public class ArraySplitUtil {
    /**
     * 按指定大小对列表分组
     * @param list
     * @param splitSize
     * @return
     */
    public List> splistList(List list, int splitSize) {
        if (null == list || list.size() == 0) {
            return null;
        }
        int listSize = list.size();
        List> newList = new ArrayList<>();
        if (listSize < splitSize) {
            newList.add(list);
            return newList;
        }
        int addLength = splitSize;
        int times = listSize / splitSize;
        if (listSize % splitSize != 0) {
            times += 1;
        }
        int start = 0;
        int end = 0;
        int last = times - 1;
        for (int i = 0; i < times; i++) {
            start = i * splitSize;
            if (i < last) {
                end = start + addLength;
            } else {
                end = listSize;
            }
            newList.add(list.subList(start, end));
        }
        return newList;
    }

    /**
     * 按指定大小对数组分组
     * @param array
     * @param splitSize
     * @return
     */
    public List splistArray(T[] array, int splitSize) {
        if (null == array) {
            return null;
        }
        int listSize = array.length;
        List newList = new ArrayList<>();
        if (listSize < splitSize) {
            newList.add(array);
            return newList;
        }
        int addLength = splitSize;
        int times = listSize / splitSize;
        if (listSize % splitSize != 0) {
            times += 1;
        }
        int start = 0;
        int end = 0;
        int last = times - 1;
        for (int i = 0; i < times; i++) {
            start = i * splitSize;
            if (i < last) {
                end = start + addLength;
            } else {
                end = listSize;
            }
            newList.add(Arrays.copyOfRange(array, start, end));
        }
        return newList;
    }

    public static  ArraySplitUtil build(){
        return new ArraySplitUtil<>();
    }
}
5.多任务执行助手类

							

								小邮包 包月订购包年程序
								

									小邮包 包月订购包年程序
									
小邮包-包月订购包年服务网，该程序由好买卖商城开发，程序采用PHP+MYSQL架设，程序商业模式为目前最为火爆的包月订制包年服务模式，这种包年订购在国外网站已经热火很多年了，并且已经发展到一定规模，像英国的男士用品网站BlackSocks，一年的袜子购买量更是达到了1000万双。功能：1、实现多产品上线，2、不用注册也可以直接下单购买，3、集成目前主流支付接口，4、下单发货均有邮件提醒。

								

								下载 
							

						


立即学习“Java免费学习笔记（深入）”；
package com.visy.helper;

import com.baomidou.mybatisplus.toolkit.CollectionUtils;
import com.google.common.collect.Lists;
import com.visy.utils.ArraySplitUtil;
import com.visy.threadpool.ThreadPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 多任务助手
 * @author visy.wang
 * @date 2022/5/9 14:38
 */
@Service
public class MultiTaskHelper {
    @Autowired
    private ThreadPoolConfig threadPoolConfig;
    private static final Map> ArraySplitUtilCache = new ConcurrentHashMap<>();

    public  List> createAndRunListTask(List list, Function handler){
        return createAndRunListTask(list, null, handler);
    }

    public  List> createAndRunListTaskV2(List list, Function, List> handler){
        return createAndRunListTask(list, handler, null);
    }

    public  void createAndRunListTaskWithoutReturn(List list, Consumer handler){
        createAndRunListTaskWithoutReturn(list, null, handler);
    }

    public  void createAndRunListTaskWithoutReturnV2(List list, Consumer> handler){
        createAndRunListTaskWithoutReturn(list, handler, null);
    }

    /**
     * 把列表按线程数分组
     * @param list 列表
     * @return 分组后的列表
     */
    @SuppressWarnings("unchecked")
    private  List> listSplit(List list){
        String key = list.get(0).getClass().getName();
        int groupSize = threadPoolConfig.getTheadPoolProperties().getGroupSize();
        ArraySplitUtil arraySplitUtil = (ArraySplitUtil)ArraySplitUtilCache.get(key);
        if(Objects.isNull(arraySplitUtil)){
            arraySplitUtil = ArraySplitUtil.build();
            ArraySplitUtilCache.put(key, arraySplitUtil);
        }
        return arraySplitUtil.splistList(list, groupSize);
    }

    /**
     * 创建并运行多任务
     * @param list 输入数据列表
     * @param handler1 处理器1 (优先级使用)
     * @param handler2 处理器2
     * @param  输入数据类型
     * @param  输出数据类型
     * @return 执行结果分组列表
     */
    private  List> createAndRunListTask(List list,  Function, List> handler1, Function handler2){
        List> listGroup = listSplit(list);
        //设定每个组的任务
        List>> taskList = Lists.newArrayListWithExpectedSize(listGroup.size());
        listGroup.stream().filter(CollectionUtils::isNotEmpty).forEach(subList -> {
            taskList.add(() -> {
                if(Objects.nonNull(handler1)){
                    return handler1.apply(subList);
                }else if(Objects.nonNull(handler2)){
                    return subList.stream().map(handler2).collect(Collectors.toList());
                }else{
                    return null;
                }
            });
        });
        return threadPoolConfig.doConcurrentTask(taskList);
    }

    /**
     * 创建并运行多任务(无返回结果)
     * @param list 输入数据列表
     * @param handler1 处理器1 (优先级更高)
     * @param handler2 处理器2
     * @param  输入数据类型
     */
    private  void createAndRunListTaskWithoutReturn(List list, Consumer> handler1, Consumer handler2){
        List> listGroup = listSplit(list);
        //设定每个组的任务
        List>> taskList = Lists.newArrayListWithExpectedSize(listGroup.size());
        listGroup.stream().filter(CollectionUtils::isNotEmpty).forEach(subList -> {
            taskList.add(() -> {
                if(Objects.nonNull(handler1)){
                    handler1.accept(subList);
                }else if(Objects.nonNull(handler2)){
                    subList.forEach(handler2);
                }
                return null;
            });
        });
        threadPoolConfig.doConcurrentTask(taskList);
    }
}
6.多任务助手使用:
@Autowired
package com.zoom.fleet.schedule.service;

import com.visy.helper.MultiTaskHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 多任务助手使用示例
 * @author visy.wang
 * @date 2022/5/13 14:11
 */
@Service
public class MultiTaskTest {
    @Autowired
    private MultiTaskHelper multiTaskHelper;

    private void test(){

        //待多任务执行的数据列表
        List idList = new ArrayList<>();

        //1.有返回结果的执行方式一， 定义单个数据的处理逻辑，返回多任务执行结果和合集
        List> resultList = multiTaskHelper.createAndRunListTask(idList, id->{
            //每一项数据的业务代码
            return Long.valueOf(id);
        });

        //2.有返回结果的执行方式二， 定义单个数线程的处理逻辑，返回多任务执行结果和合集
        resultList = multiTaskHelper.createAndRunListTaskV2(idList, subIdList->{
            //每一个线程下列表操作的业务代码
            return subIdList.stream().map(id->{
                //每一项数据的业务代码
                return Long.valueOf(id);
            }).collect(Collectors.toList());
        });

        //3.无返回结果的执行方式一， 定义单个数据的处理逻辑
        multiTaskHelper.createAndRunListTaskWithoutReturn(idList, id->{
            //每一项数据的业务代码...
        });

        //3.无返回结果的执行方式一， 定义单个数据的处理逻辑
        multiTaskHelper.createAndRunListTaskWithoutReturnV2(idList, subIdList->{
            subIdList.forEach(id->{
                //每一项数据的业务代码...
            });
            //继续操作subIdList...
        });
    }
}
					
					

													

								
相关文章

							

							

																	
										
在Java里如何在Windows系统配置Java环境_Java系统变量设置说明

									
																	
										
在Java里如何使用new关键字_对象创建流程解析

									
																	
										
Java 中同一个类为何能被不同 ClassLoader 重复加载？

									
																	
										
Java 中类可被不同 ClassLoader 多次加载的原理与实践

									
																	
										
如何使用 Java 8 Stream 对数字列表进行平方、过滤并计算平均值

									
															

													

							

								java速学教程(入门到精通)
								

									java速学教程(入门到精通)
									
java怎么学习？java怎么入门？java在哪学？java怎么学才快？不用担心，这里为大家提供了java速学教程(入门到精通)，有需要的小伙伴保存下载就能学习啦！

								

								下载 
							

						
							

								
相关标签:

								

									java								

							

						
						
本站声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

						

													上一篇：Java中不同锁模式下插队的行为分析。
													下一篇：如何理解和使用Java适配器模式？
												

					


					

													

								

									
 
										
作者最新文章

									

								

																	

										

											
												
如何解决复杂应用中动态URL和重定向管理难题，使用spryker/url模块轻松搞定

											
											

												
2025-09-12 10:39

											

										

								

																	

										

											
												
如何在Spryker项目中实现前端与后端高效通信？Spryker/Zed-Request与Composer助你轻松连接！

											
											

												
2025-09-12 12:40

											

										

								

																	

										

											
												
如何高效生成唯一ID？Ramsey/Uuid助你解决分布式系统中的ID难题

											
											

												
2025-09-13 09:51

											

										

								

																	

										

											
												
Yii2数据库迁移总是手动写？insolita/yii2-migration-generator助你告别繁琐，实现自动化！

											
											

												
2025-09-15 09:38

											

										

								

																	

										

											
												
如何解决复杂系统可视化难题，Spryker/Graphviz助你轻松绘制依赖与状态图

											
											

												
2025-09-15 09:52

											

										

								

																	

										

											
												
如何高效生成订单/发票号？SprykerSequenceNumber模块助你轻松搞定

											
											

												
2025-09-16 10:01

											

										

								

																	

										

											
												
如何解决电商平台商品属性管理混乱的问题，使用SprykerProductAttribute模块助你实现灵活高效的数据管理

											
											

												
2025-09-16 12:23

											

										

								

																	

										

											
												
解锁夸克浏览器AI搜索新功能_掌握夸克AI搜索的进阶玩法

											
											

												
2025-10-13 17:08

											

										

								

																	

										

											
												
升级夸克浏览器体验AI搜索_夸克AI搜索核心功能深度解析

											
											

												
2025-10-28 20:58

											

										

								

																	

										

											
												
微信朋友圈能不能定时发 微信朋友圈定时发送辅助工具使用

											
											

												
2026-01-11 08:41

											

										

								

															

						
						

							

								
 
									
热门AI工具

								

								更多
							


							

																	

										
											DeepSeek
											

												
DeepSeek

												
幻方量化公司旗下的开源大模型平台

																									

																												
AI大模型

																													
开放平台

																											

																							

										
									

																	

										
											豆包大模型
											

												
豆包大模型

												
字节跳动自主研发的一系列大型语言模型

																									

																												
AI大模型

																											

																							

										
									

																	

										
											通义千问
											

												
通义千问

												
阿里巴巴推出的全能AI助手

																									

																												
AI大模型

																											

																							

										
									

																	

										
											腾讯元宝
											

												
腾讯元宝

												
腾讯混元平台推出的AI助手

																									

																												
文档处理

																													
Excel 表格

																											

																							

										
									

																	

										
											文心一言
											

												
文心一言

												
文心一言是百度开发的AI聊天机器人，通过对话可以生成各种形式的内容。

																									

																												
AI大模型

																													
中文写作

																											

																							

										
									

																	

										
											讯飞写作
											

												
讯飞写作

												
基于讯飞星火大模型的AI写作工具，可以快速生成新闻稿件、品宣文案、工作总结、心得体会等各种文文稿

																									

																												
中文写作

																													
写作工具

																											

																							

										
									

																	

										
											即梦AI
											

												
即梦AI

												
一站式AI创作平台，免费AI图片和视频生成。

																									

																												
图片拼接

																													
图画生成

																											

																							

										
									

																	

										
											ChatGPT
											

												
ChatGPT

												
最最强大的AI聊天机器人程序，ChatGPT不单是聊天机器人，还能进行撰写邮件、视频脚本、文案、翻译、代码等任务。

																									

																												
AI大模型

																													
中文写作

																											

																							

										
									

																	

										
											智谱清言 - 免费全能的AI助手
											

												
智谱清言 - 免费全能的AI助手

												
智谱清言 - 免费全能的AI助手

																									

																												
AI大模型

																													
PDF 文档

																											

																							

										
									

															





						


					



				


			
			

				

                    
                

				

					

						
 
							
相关专题

						

						更多
					

					

													

								高德地图升级方法汇总
								

									高德地图升级方法汇总
									
本专题整合了高德地图升级相关教程，阅读专题下面的文章了解更多详细内容。

									

										
 
											
43

										

										
 
											
2026.01.16

										

									

								

							

													

								全民K歌得高分教程大全
								

									全民K歌得高分教程大全
									
本专题整合了全民K歌得高分技巧汇总，阅读专题下面的文章了解更多详细内容。

									

										
 
											
84

										

										
 
											
2026.01.16

										

									

								

							

													

								C++ 单元测试与代码质量保障
								

									C++ 单元测试与代码质量保障
									
本专题系统讲解 C++ 在单元测试与代码质量保障方面的实战方法，包括测试驱动开发理念、Google Test/Google Mock 的使用、测试用例设计、边界条件验证、持续集成中的自动化测试流程，以及常见代码质量问题的发现与修复。通过工程化示例，帮助开发者建立 可测试、可维护、高质量的 C++ 项目体系。

									

										
 
											
24

										

										
 
											
2026.01.16

										

									

								

							

													

								java数据库连接教程大全
								

									java数据库连接教程大全
									
本专题整合了java数据库连接相关教程，阅读专题下面的文章了解更多详细内容。

									

										
 
											
35

										

										
 
											
2026.01.15

										

									

								

							

													

								Java音频处理教程汇总
								

									Java音频处理教程汇总
									
本专题整合了java音频处理教程大全，阅读专题下面的文章了解更多详细内容。

									

										
 
											
16

										

										
 
											
2026.01.15

										

									

								

							

													

								windows查看wifi密码教程大全
								

									windows查看wifi密码教程大全
									
本专题整合了windows查看wifi密码教程大全，阅读专题下面的文章了解更多详细内容。

									

										
 
											
56

										

										
 
											
2026.01.15

										

									

								

							

													

								浏览器缓存清理方法汇总
								

									浏览器缓存清理方法汇总
									
本专题整合了浏览器缓存清理教程汇总，阅读专题下面的文章了解更多详细内容。

									

										
 
											
16

										

										
 
											
2026.01.15

										

									

								

							

													

								ps图片相关教程汇总
								

									ps图片相关教程汇总
									
本专题整合了ps图片设置相关教程合集，阅读专题下面的文章了解更多详细内容。

									

										
 
											
9

										

										
 
											
2026.01.15

										

									

								

							

													

								ppt一键生成相关合集
								

									ppt一键生成相关合集
									
本专题整合了ppt一键生成相关教程汇总，阅读专题下面的的文章了解更多详细内容。

									

										
 
											
26

										

										
 
											
2026.01.15

										

									

								

							

											

				


				

					

						
 
							
热门下载

						

						更多
					

					

						

							
网站特效  
 /
							
网站源码 
 /
							
网站素材 
 /
							
前端模板 

						

						
						
						
						
					

					

				


				

					
                




				

					

						
 
							
相关下载

						

						更多
					

					

											
小邮包 包月订购包年程序

											
BJXSHOP网上开店专家

											
跳蚤市场

											
SLStuan手拉手团购程序(仿拉手网)

											
DaGaoPeng(大高朋网团购程序)

											
多奥淘宝客程序API免费版 F8.0

											
网趣购物系统精装版

										


				


				

					

						
 
							
精品课程

						

						更多
					

					

						

							
相关推荐  
 /
							
热门推荐 
 /
							
最新课程 

						

						

													

								
									Kotlin 教程
								
								

									Kotlin 教程

									

										
共23课时 | 2.6万人学习

									

								

							

													

								
									C# 教程
								
								

									C# 教程

									

										
共94课时 | 6.9万人学习

									

								

							

													

								
									Java 教程
								
								

									Java 教程

									

										
共578课时 | 46.9万人学习

									

								

							

												


						

						
						

					

				


				

					

						
 
							
最新文章

						

						更多
					

					

													
Java开发环境搭建完成后如何验证是否成功

													
在Java中如何开发简单的成绩管理系统_Java集合应用实践解析

													
Java里TreeSet适合什么场景_Java有序Set使用说明

													
在Java中如何搭建命令行开发环境_纯命令行Java环境配置方法

													
在Java中如何安装并使用Postman_Java接口测试工具解析

													
JavaFX怎么播放音频 JavaFX MediaPlayer播放音乐入门教程【实例】

													
在Java里如何在Windows系统配置Java环境_Java系统变量设置说明

													
在Java里如何使用new关键字_对象创建流程解析

													
Android Studio 升级后 R 类无法识别的完整解决方案

													
Java 中同一个类为何能被不同 ClassLoader 重复加载？

											


				







			




		

	
	
	

    

        

            

                

                    

                        关于我们
                        免责申明
                        举报中心
                        意见反馈
                        讲师合作
                        广告合作
                        最新更新
                                                

                    

                    
php中文网：公益在线php培训，帮助PHP学习者快速成长！

                    

                      
                        关注服务号
                        
                      
                        
                        技术交流群
                        
                      
                        

                    

                

                
            

            

                

                    
                    

                        
PHP中文网订阅号

                        
每天精选资源文章推送

                    

                

            

        

    

    

        
Copyright 2014-2026 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号

    













	
	
		
	
	


    
  • 
        
    
            
    
                
                    
                    
    PHP学习
    
                    
            
    
        
    
    
    • 
    
  • 
        
    
            
    
                
                    
                    
    技术支持
    
                    
            
    
        
    
    
    • 
    
  • 
        
    
            
    
                
                    
                    
    返回顶部
    
                    
            
    
        
    
    
    •