并发编程：Kotlin Coroutines vs Java concurrency

三少爷的鞋2023-10-21 10:32

引言

实际开发过程中我们经常需要处理并发操作，以提高性能和资源利用率。并发编程不仅可以加快应用程序的响应速度，还可以充分利用多核处理器的性能。在这篇文章中，我们将深入探讨并比较两种不同的方式来处理并发编程：Kotlin Coroutines和Java Concurrency。这两种技术在不同的编程语境和需求下都有它们的优点和适用场景。通过了解它们的特点，您将能够更明智地选择合适的并发工具，以满足您的项目需求。

从需求出发:异步获取User和Avatar

已有两个异步接口,模拟如下:

java 复制代码 
/**
* 模拟网络请求
* Java 版本
*/
public class ClientUtils {
  static ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);

  /**
   * getUser
   *
   * @param userId
   * @param userCallback
   */
  public static void getUser(int userId, UserCallback userCallback) {
      executorService.execute(() -> {
          long sleepTime = new Random().nextInt(500);
          try {
              Thread.sleep(sleepTime);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          userCallback.onCallback(new User(userId, sleepTime + "", "avatar", ""));
      });

  }

  /**
   * getAvatar
   *
   * @param user
   * @param userCallback
   * @throws InterruptedException
   */
  public static void getUserAvatar(User user, UserCallback userCallback) {

      executorService.execute(() -> {
          int sleepTime = new Random().nextInt(1000);
          try {
              Thread.sleep(sleepTime);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          user.setFile(sleepTime + ".png");
          userCallback.onCallback(user);
      });
  }


}

interface UserCallback {
  void onCallback(User user);
}

需求分析

我们的需求是获取用户信息（User）和用户头像（Avatar）。这两个操作是相互独立的，但必须按顺序执行：首先获取用户信息，然后使用该信息获取用户头像。这种情况下，异步操作是必不可少的，因为网络请求通常需要时间来完成。

java 异步回调

最简单直接的方式,在异步回调里直接调用异步回调

typescript 复制代码 
/**
 * getUser callBack
 */
public class GetUser {

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        ClientUtils.getUser(1, new UserCallback() {
            @Override
            public void onCallback(User user) {
                LogKt.log(user.toString());
                ClientUtils.getUserAvatar(user, new UserCallback() {
                    @Override
                    public void onCallback(User user) {
                        LogKt.log(user.toString());
                        LogKt.log("costTime -->"+(System.currentTimeMillis() - startTime));
                    }
                });
            }
        });
    }
}

这种实现方式简单,但是缺点也很明显,接口多了容易形成回调地狱,代码难以维护且调用流程脱离了主流程。

java 异步加锁变为同步

使用JUC包下的CountDownLatch 工具让异步接口变成同步,如下:

scss 复制代码 
    /**
     * 加锁
     */
    public static User getUser() {
        CountDownLatch countDown = new CountDownLatch(1);
        User[] result = new User[1];
        ClientUtils.getUser(1, new UserCallback() {
            @Override
            public void onCallback(User user) {
                result[0] = user;
                countDown.countDown();
            }
        });
        try {
            countDown.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return result[0];
    }

    /**
     * getAvater
     *
     * @param user
     * @return
     */
    public static User getUserAvatar(User user) {
        CountDownLatch countDown = new CountDownLatch(1);
        User[] result = new User[1];
        ClientUtils.getUserAvatar(user, new UserCallback() {
            @Override
            public void onCallback(User user) {
                result[0] = user;
                countDown.countDown();
                //result = user;

            }
        });
        try {
            countDown.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return result[0];

    }
}

业务直接调用即可,如下所示:

ini 复制代码 
long startTime = System.currentTimeMillis();
User user = getUser();
user = getUserAvatar(user);
LogKt.log(user.toString());
LogKt.log("costTime -->"+(System.currentTimeMillis() - startTime));

业务调用方看起来简单多了,但是异步转同步的过程需要加锁,这部分容易出错。

Kotlin 协程实现

Kotlin协程可以优雅的实现异步同步化,让业务方只关心业务,而无需关心线程切换的细节。

先把Kotlin版本的异步回调:

kotlin 复制代码 
/**
 * 模拟客户端请求
 */
object ClientManager {

    var executor: Executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2)
    val customDispatchers = executor.asCoroutineDispatcher()

    /**
     * getUser
     */
    fun getUser(userId: Int, callback: (User) -> Unit) {
        executor.execute {
            val sleepTime = Random().nextInt(500)
            Thread.sleep(sleepTime.toLong())
            callback(User(userId, sleepTime.toString(), "avatar", ""))
        }
    }

    /**
     * getAvatar
     */
    fun getUserAvatar(user: User, callback: (User) -> Unit) {
        executor.execute {
            val sleepTime = Random().nextInt(1000)
            try {
                Thread.sleep(sleepTime.toLong())
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
            user.file = "$sleepTime.png"
            callback(user)
        }
    }


}

使用 suspendCoroutine实现异步代码同步化:

kotlin 复制代码 
/**
 * 异步同步化
 */
suspend fun getUserAsync2(userId: Int): User = suspendCoroutine { continuation ->
    ClientManager.getUser(userId) {
        continuation.resume(it)
    }
}


/**
 * 异步同步化
 */
suspend fun getUserAvatarAsync2(user: User): User = suspendCoroutine { continuation ->
    ClientManager.getUserAvatar(user) {
        continuation.resume(it)
    }
}

这里我们暂时先不关心取消与异常。业务调用方如下:

scss 复制代码 
val costTime = measureTimeMillis {
    val user = getUserAsync(1);
    val userAvatar = getUserAvatarAsync2(user)
    log(userAvatar.toString())
}
log("cost -->$costTime")

是不是看起来比Java版本简洁许多,这还不够。

需求变更:首先并发访问100个User,然后在并发访问100个Avatar

java实现 同样适用JUC下的CountDownLatch:

ini 复制代码 
/**
 * 并发下载100个User
 * 然后并发下载100个头像
 * Java
 */
public class UserDownload {

    public static void main(String[] args) throws InterruptedException {

        long  startTime = System.currentTimeMillis();
        List<Integer> userId = new ArrayList<>();
        for (int i = 1; i <= 100; i++) {
            userId.add(i);
        }
        Map<Integer,User> map = new ConcurrentHashMap<>();
        log("开始下载user");
        AtomicInteger atomicInteger  = new AtomicInteger(userId.size());
        CountDownLatch countDownLatch = new CountDownLatch(userId.size());
        for (Integer id : userId) {
            ClientUtils.getUser(id, user -> {
                log("atomicInteger-->"+  atomicInteger.decrementAndGet());
                map.put(id,user);
                countDownLatch.countDown();
            });

        }
        countDownLatch.await();
        log("atomicInteger-->"+atomicInteger.get());
        log("开始下载头像");

        AtomicInteger atomicIntegerAvatar  = new AtomicInteger(userId.size());
        CountDownLatch countDownLatchDownload= new CountDownLatch(userId.size());
        log("map size-->"+map.size());
        for (User user : map.values()){
            ClientUtils.getUserAvatar(user, new UserCallback() {
                @Override
                public void onCallback(User user) {
                    log("atomicIntegerAvatar-->"+  atomicIntegerAvatar.decrementAndGet());
                    map.put(user.getUserId(),user);
                    countDownLatchDownload.countDown();
                }
            });

        }
        countDownLatchDownload.await();
        long costTime = (System.currentTimeMillis() -startTime)/1000;
        log("costTime -->"+costTime);
    }

}

这里并发访问条件下,需要记录User与下载次数,我使用了并发map与AtomicInteger。

Kotlin 协程实现

kotlin 复制代码 
/**
 * 并发下载100个User
 * 然后并发下载100个头像
 * Kotlin
 */
fun main() = runBlocking {

    val startTime = System.currentTimeMillis()
    val userIds: MutableList<Int> = ArrayList()
    for (i in 1..100) {
        userIds.add(i)
    }
    var count = userIds.size
    val map: MutableMap<Int, User> = HashMap()
    val deferredResults = userIds.map { userId ->
        async {
            val user = getUserAsync2(userId)
            log("userId-->$userId :::: user --->  $user")
            map[userId] = user
            map
        }
    }


    // 获取每个 async 任务的结果
    val results = deferredResults.map { deferred ->
        count--
        log("count  $count")
        deferred.await()

    }

    log("map -->${map.size}")
    val deferredAvatar = map.map { map ->
        async {
            getUserAvatarAsync2(map.value)
        }
    }


    var countAvatar = results.size
    val resultAvatar = deferredAvatar.map { deferred ->
        countAvatar--
        log("countAvatar  $countAvatar")
        deferred.await()

    }

    val costTime = (System.currentTimeMillis() - startTime) / 1000
    log("costTime-->$costTime")
    log("user -> $resultAvatar")
}

在协程的加持下,代码又变得简洁起来,没有锁,没有异步回调,没有并发容器(单线程调度器是线程安全的)。

Kotlin Coroutines vs Java concurrency

Java Concurrency

Java Concurrency API是Java平台上用于处理并发任务的传统工具。以下是Java Concurrency的关键特点：

  1. 线程和执行器框架：Java Concurrency提供了多线程和执行器框架，允许您创建和管理线程，以在多核处理器上执行并发任务。
  2. 同步和锁 ：Java Concurrency支持传统的同步和锁机制，如synchronized关键字和ReentrantLock，用于确保多线程环境下的数据同步和安全性。
  3. 线程池：Java Concurrency提供了线程池来管理线程的生命周期，减少了线程的创建和销毁开销。
  4. 并发集合 ：Java Concurrency提供了并发集合类，如ConcurrentHashMap和ConcurrentLinkedQueue，用于在多线程环境下安全地操作数据结构。
  5. 手动的线程管理：您需要明确地创建和管理线程池中的线程。 灵活的任务提交：您可以将任务作为 Runnable 或 Callable 对象提交给执行器。 线程同步：使用 CountDownLatch 和 AtomicInteger 等同步机制进行协调。 更多的控制：Java Executor 提供了更细粒度的线程池大小和任务提交控制。

Kotlin Coroutines

Kotlin Coroutines是一种异步编程框架，它在Kotlin语言中引入了挂起函数的概念，使得异步代码更加直观和容易理解。以下是Kotlin Coroutines的关键优点：

  1. 简洁性和可读性 ：Kotlin Coroutines使用suspend关键字，使异步代码看起来像是同步代码，提高了代码的可读性。
  2. 取消和超时处理：Coroutines内置了取消和超时处理机制，使得处理任务取消或在超时后进行处理变得简单。
  3. 协程作用域：Kotlin Coroutines允许您创建协程作用域，以管理协程的生命周期，防止资源泄漏。
  4. 并发组合器 ：Coroutines提供了各种方便的并发组合器，例如async/await和launch，使并发编程更加容易。

总结

Kotlin 协程中也有等待的过程，但与传统的 Java 多线程方式相比，有一些关键的不同之处。以下是 Kotlin 协程和 Java 多线程之间的一些主要不同之处：

  1. 挂起与阻塞：
  • Kotlin 协程使用挂起来代替阻塞。当协程中的操作需要等待时，它会被挂起，让出线程，然后允许其他协程在同一个线程中执行。这样可以更高效地利用线程，而不会阻塞整个线程。
  • Java 多线程使用阻塞来等待，即线程会在某个操作上阻塞，直到操作完成或等待超时。
  1. 无需显式锁：
  • Kotlin 协程通过挂起和恢复来避免了显式的锁机制。协程之间的数据共享是更安全的，因为它们不会直接在不同线程中执行，从而避免了多线程竞争的问题。
  • Java 多线程通常需要使用锁来保护共享资源，以防止多个线程之间的竞争条件和数据不一致性。
  1. 代码简洁性：
  • Kotlin 协程使用顺序的代码结构，更易于理解和编写。协程代码通常比传统的多线程代码更简洁，因为它们隐藏了大部分线程管理细节。
  • Java 多线程代码可能需要处理更多的线程管理和同步细节，导致代码变得复杂。
  1. 异常处理：
  • Kotlin 协程通过异常传播和处理提供了更直观的方式来处理异常。异常在协程之间传播，可以使用 try-catch 块捕获异常。
  • Java 多线程代码中的异常处理可能需要更多的手动操作，有时可能较为繁琐。
  1. 线程切换：
  • Kotlin 协程内部管理线程切换，使得在协程之间进行切换更为高效。
  • Java 多线程通常需要手动进行线程切换，可能需要使用 ExecutorService 或 Future 来管理线程。

高效和轻量，都不是 Kotlin 协程的核心竞争力。 Kotlin 协程的核心竞争力在于：它能简化异步并发任务。 Kotlin 协程提供了更高级、更简洁、更易读的方式来处理异步任务和并发操作。它的语法和语义更贴近顺序执行，而底层细节由协程库自动管理。Java Executor 则需要更多手动的线程管理和同步，代码可能会更复杂。选择使用哪种方式取决于您的偏好、项目需求和已有代码基础。

源码

[[github.com/ThirdPrince...]

相关推荐
qq_4419960515 分钟前
Mybatis官方生成器使用示例
java·mybatis
巨大八爪鱼22 分钟前
XP系统下用mod_jk 1.2.40整合apache2.2.16和tomcat 6.0.29，让apache可以同时访问php和jsp页面
java·tomcat·apache·mod_jk
码上一元2 小时前
SpringBoot自动装配原理解析
java·spring boot·后端
计算机-秋大田2 小时前
基于微信小程序的养老院管理系统的设计与实现，LW+源码+讲解
java·spring boot·微信小程序·小程序·vue
魔道不误砍柴功4 小时前
简单叙述 Spring Boot 启动过程
java·数据库·spring boot
失落的香蕉4 小时前
C语言串讲-2之指针和结构体
java·c语言·开发语言
枫叶_v4 小时前
【SpringBoot】22 Txt、Csv文件的读取和写入
java·spring boot·后端
wclass-zhengge4 小时前
SpringCloud篇（配置中心 - Nacos）
java·spring·spring cloud
路在脚下@4 小时前
Springboot 的Servlet Web 应用、响应式 Web 应用（Reactive）以及非 Web 应用（None）的特点和适用场景
java·spring boot·servlet
黑马师兄4 小时前
SpringBoot
java·spring
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【Flutter】基于 GetX 实现 Dio 的生命周期自动化