Java & Groovy & Scala & Kotlin - 30.Thread 与 CompletableFuture

Overview

本节主要介绍异常任务最核心的概念：线程。

Java

Thread

线程主要用于执行并发任务，提高 CPU 的运行效率。在Java 中线程相关的概念主要有两个： Thread 和 Runnable。

Runnable 是一个只含有 run() 方法的接口，该接口定义了线程所要执行的代码。Thread 表示线程，本身实现了 Runnable 接口，可以执行自己的 run() 方法也可以执行传入的 Runnable 接口的 run() 方法。

例：

定义一个简单的线程

new Thread(() -> {
    System.out.println("async");
}, "thread-01").start();
System.out.println("sync");

Thread Pool

如果总是建立新的线程，CPU 资源很快会被耗尽，因此便有了线程池。线程池本质是预先建立好一些空闲线程放在池子中，当需要在线程中执行代码时便从池中取出空闲的线程来运行，运行完毕后线程继续放回池中，如果需要执行代码但是池中没有线程时根据不同的线程池的策略或者新建线程或者将请求放在等待队列中。

Java 中创建线程池非常简单，主要使用 Executors 这一个工具类。

例：

创建一个单线程的线程池

ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(() -> System.out.println("Running in a pool."));

Callable 与 Future

Callable 与 Future 主要用于从线程中获得返回结果。Callable 用于在线程中执行计算并返回结果，Future 用于等待线程的结果。

例：

ExecutorService service = Executors.newSingleThreadExecutor();
Callable<String> callable = () -> "Hello World";
Future<String> future = service.submit(callable);
String result = future.get();
System.out.println(result);
service.shutdown();

Timer

Timer 用于执行定时任务，也可以用 ScheduledThreadPool 进行替代。

例：

Timer timer = new Timer("timer", true);
TimerTask task = new TimerTask() {
    @Override
    public void run() {
        System.out.println("ping!");
    }
};
timer.schedule(task, 100, 100);
Thread.sleep(1000);
timer.cancel();

CompletableFuture

概念

CompletableFuture 是 Java 1.8 新加入的类，提供了事件驱动的编程模型，能够大幅简化异步调用的繁琐过程从而避免陷入回调地狱。

CompletableFuture 继承自 Future，所以也表示未来的值，但是 CompletableFuture 表示的未来的值可以是预期的，即你可以明确表明你知道将会发生什么。

创建 CompletableFuture

创建一个最简单的 CompletableFuture 的实例

CompletableFuture<Integer> firstFuture = new CompletableFuture<>();
firstFuture.complete(10);
int value = firstFuture.get();
System.out.println(value);  //  10

以上调用 complete() 表示我知道这个 Future 会返回 10。这个例子是最简单的同步调用方式，下面使用工厂类创建一个支持异步调用的 CompletableFuture 实例。

 ExecutorService service = Executors.newFixedThreadPool(10);
 CompletableFuture<Integer> secondFuture = CompletableFuture.supplyAsync(() -> {
      //  long running
      return new Random().nextInt(1000);
  }, service);

以上 supplyAsync() 创建了一个支持异步调用的 CompletableFuture，该 CompletableFuture 的任务运行在指定的线程池中。

在同一个 CompletableFuture 上执行链式操作

CompletableFuture 的用法类似 Javascript 的 Promise 编程的概念。使用 thenApplyAsync() 或 thenApply() 可以在同一个 CompletableFuture 上可以执行多个链式操作，前一个操作完成后才能执行下一个操作。

例：

CompletableFuture<String> thirdFuture = secondFuture.thenApplyAsync(integer -> {
    if (integer < 900) {
        throw new IllegalArgumentException();
    }
    return "" + integer;
});

完成 CompletableFuture

thenAcceptAsync() 或 thenAccept() 可以在一个 CompletableFuture 完成所有操作后执行收尾操作。

CompletableFuture<Void> lastFuture = thirdFuture.thenAcceptAsync(s -> System.out.println("Result is " + s));

异常处理

exceptionally() 方法会在 CompletableFuture 执行中发生异常时被调用，可以在该方法中处理异常。

CompletableFuture<String> safe1 = thirdFuture.exceptionally(throwable -> {
        //  throwable is CompletionException
        if (throwable != null && (throwable.getCause() instanceof IllegalArgumentException)) {
            return "Too small.";
        } else if (throwable != null) {
            return throwable.getMessage();
        }
        return null;
    });

或者也可以使用 handleAsync() 方法，无论异常是否发生，该方法都会被调用，所以即可以在返回前处理异常也可以处理返回值。

例：

CompletableFuture<String> safe2 = thirdFuture.handleAsync((s, throwable) -> {
    //  throwable is CompletionException
    if (throwable != null && (throwable.getCause() instanceof IllegalArgumentException)) {
        return "Result is too small.";
    } else if (throwable != null) {
        return throwable.getMessage();
    }
    return s;
});

Groovy

使用同 Java，但是由于 Groovy 暂不支持 Java 1.8 的新增特性，所以一些代码写起来会比 Java 麻烦。

Scala

Thread

用法同 Java。

ExecutionContext

ExecutionContext 可以看做 Java 中的线程池，实际上其本质也是通过 Java 的 ExecutorService 来实现的。

例：

val executor = Executors.newFixedThreadPool(1)
implicit val service = ExecutionContext.fromExecutor(executor)
service.execute(new Runnable {
  override def run(): Unit = {
    println("Running in a pool.")
  }
})

以上例子定义了一个容量为 1 的线程池，并且通过隐式转换（具体见 Scala 的隐式转换一章）使 ExecutionContext 运行在该线程池中。

除了自定义线程池之外，Scala 还有一个全局的默认线程池 scala.concurrent.ExecutionContext.Implicits.global，通常来说这个线程池仅用于测试。因为你不知道其它人或者你引用的其它库中是否有使用默认的线程池进行大量长时间操作。

Future

Scala 中的 Future 表示尚未完成的计算结果，执行在指定的 ExecutionContext 中。一个 Future 一旦被赋值后就不可被改变，可以用于编写高效的并行代码。

创建 Future

使用 Future{} 创建 Future 对象

val s = "Hello"
val f1: Future[String] = Future {
  s + " future!"
}

回调

Future 支持三种回调方式

  • onSuccess 用于在 Future 完成后对计算结果进行某些操作
  • onFailure 用于处理在 Future 计算过程中发生的异常
  • onComplete 用于在 Future 处理完成后进行某些操作，其接收的参数为 Try[T] 类型，子类为 Success[T] 和 Failure[T]，所以可以在其方法体内同时完成成功和失败的后续处理。

例：

val s = "Hello"
//  使用 Future{} 创建 Future 对象
val f1: Future[String] = Future {
  s + " future!"
}
f1 onSuccess {
    case msg =>
        println(msg)
}
f1 onFailure {
    case e =>
        e.printStackTrace()
}
f1 onComplete {
    case Success(msg) => println(s"Success $msg")
    case Failure(e) => println(s"Failure ${e.getMessage}")
}

一个 Future 上 可以定义多个 onSuccess 等类型的回调方法，但是所有的回调方法返回值都是 Unit 所以无法进行链式操作，同时执行多个回调的顺序的也不保证。

例：

val f2 = Future {
    Thread.sleep(10)
}
f2 onSuccess {
    case _ => println("a")
}
f2 onSuccess {
    case _ => println("b")
}
f2 onSuccess {
    case _ => println("c")
}

组合

Callback 虽然方便，但是在复杂场景下光使用 Callback 很容易陷入回调地狱。

最简单的回调地狱

例：

Future {
    1
} onSuccess {
    case x => Future {
        x + 3
    } onSuccess {
        case x => Future {
            x * 10
        } onSuccess {
            case x =>
                println(s"Result of callback hell is $x") //  40
        }
    }
}

为此 Scala 为 Future 提供了多种组合方式。

map

map 用于在 Future 执行完毕后产生新的 Future 并执行后续操作，无论异常是否会发生，Future 的结果都会进行传递。

例：

val f1 = Future {
    1   //  or 1/0
}
val f2 = f1 map { x =>
    x + 3
}
f2 map { x =>
    x * 10
} onComplete {
    case Success(x) => println(s"Result of map is $x") //  40
    case Failure(e) => e.printStackTrace()
}

Recovery

recover 用于在 Future 执行过程中发生异常时进行一些拯救工作。

例：

Future {
    1 / 0
} recover {
    case e: ArithmeticException => 0
} map { x =>
    x + 3
} map { x =>
    x * 10
} onComplete {
    case Success(x) => println(s"Result of recover is $x") //  30
    case Failure(e) => e.printStackTrace()
}

Fallback

fallback 用于在 Future 执行过程中发生异常时执行另一个 Future。如果异常没有发生，原始 Future 的结果会被返回。如果原始 Future 发生异常，新 Future 成功执行则返回新 Future 的结果，如果新 Future 中也发生异常，则原始 Future 的异常会被返回。

例：

val f3 = Future {
    1 / 0
}
val f4 = Future {
    10
}
f3 fallbackTo f4 map { x =>
    x + 3
} onComplete {
    case Success(x) => println(s"Result of fallback is $x") //  13
    case Failure(e) => e.printStackTrace()
}

Then

then 听起来容易让人混淆，以为是连续多个 Future，前一个执行完的结果会被传递到后一个。但是实际 then 是为了解决副作用的问题，即 then 连接的多个 Furtue 总是返回初始 Future 的结果。

例：

Future {
    1
} andThen {
    case Success(x) =>
        x + 1
} andThen {
    case Success(x) =>
        x + 10
} andThen {
    case Success(x) =>
        println(s"Result of then is $x") //  1
}

由以上例子可知 x 的值并没有发生改变。

Blocking

Future 可以像 Java 的 Future 一样通过阻塞操作获得执行结果。

例：

val f1 = Future {
  1
}
val result = Await result(f1, Duration(3, TimeUnit.SECONDS))
println(result)

Promise

Promise 与 Future 不同，Future 只提供了读取计算值的接口，而 Promise 是一个拥有单个 Future 的容器，提供了写入计算值的接口。Java 1.8 提供的 CompletableFuture 就与 Promise 有些相似。

Promise 可以通过调用 success()，complete()，failure() 来直接调用其内部 Future 对应的 onSuccess() 等方法。

例：

val p1 = Promise[Int]()
val f1 = p1.future
Future {
  val i = Random.nextInt(100)
  p1.success(i)
}
Future {
  f1 onSuccess {
    case x => println(x)
  }
}

Promise 在计算完成后就不允许再进行计算，否则会抛出异常，所以可以使用 tryXXX() 版本来替换以上版本来避免异常的发生。

p1.trySuccess(1)

Promise 也可以使用 completeWith() 方法来调用其它 Future 来代替其内置的 Future 进行计算

例：

 def heavyFuture = {
  val p = Promise[Int]()
  val f = Future {
    1000
  }
  p completeWith f
  p.future
}

val f = heavyFuture
f onSuccess { case x => println(x) } // 1000

SyncVar

SyncVar 负责存储单一值，其所有操作都是同步的，所以可以通过它安全地访问各种可变对象。

其最主要的由三个方法：get()，take()，put()，其中 get() 和 take() 都负责从对象中获取值，且提供了无参版本和有超时时间的版本，区别是 get() 仅仅取出数据，而 take() 取出后会把原来的数据删除。

例：

val v = new SyncVar[Int]
Future {
  Thread.sleep(10)
  v.put(3)
}
var result = v.get
println("result", result, Thread.currentThread().getName) //(result,3,main)

result = v.take()
println("take", result, Thread.currentThread().getName) //(take,3,main)

//  以下代码由于值已经被取出所以会一直阻塞下去
v.get

Kotlin

Kotlin 基本就是直接调用 Java 代码，但是由于 Kotlin 对部分方法进行了包装，所以可以节省一定的代码量。

Thread

定义一个简单自动启动的线程

thread {
    println("async")
}
println("sync")

Kotlin 可以直接使用 Lambda 表达式生成 Thread，在创建时也可以像以下方法一样传入默认参数。

thread(start = false,
        isDaemon = true,
        name = "t1") {
    println("running")
}.start()

Thread Pool

创建一个单线程的线程池

val service = Executors.newSingleThreadExecutor()
service.execute {
    println("Running in a pool.")
}

Callable 与 Future

val future = service.submit(
        Callable() {
            "Hello World"
        }
)
val result = future.get()
println(result)
service.shutdown()

Timer

val fixedRateTimer = fixedRateTimer(name = "timer",
        daemon = true, initialDelay = 100, period = 100) {
    println("ping!")
}
Thread.sleep(1000)
fixedRateTimer.cancel()

CompletableFuture

val firstFuture = CompletableFuture<Int>()
firstFuture.complete(10)
println(firstFuture.get())

service = Executors.newFixedThreadPool(10)
val secondFuture = CompletableFuture.supplyAsync(Supplier {
    Random().nextInt(1000)
}, service)
println(secondFuture.get())
service.shutdown()

Summary

  • 不同语言的内部实现都是依赖 Java API，所以非常相似
  • Scala 的 Future 和 Promise 和 Java 1.8 引入的 CompletableFuture 可以更好的写出异步代码

文章源码见 https://github.com/SidneyXu/JGSK 仓库的 _30_thread_future 小节

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 157,198评论 4赞 359
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 66,663评论 1赞 290
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 106,985评论 0赞 237
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,673评论 0赞 202
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 51,994评论 3赞 285
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,399评论 1赞 211
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,717评论 2赞 310
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,407评论 0赞 194
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,112评论 1赞 239
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,371评论 2赞 241
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,891评论 1赞 256
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,255评论 2赞 250
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 32,881评论 3赞 233
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,010评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,764评论 0赞 192
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,412评论 2赞 269
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,299评论 2赞 260

推荐阅读更多精彩内容

  • Java线程面试题
    下面是我自己收集整理的Java线程相关的面试题，可以用它来好好准备面试。 参考文档：-《Java核心技术 卷一》-...
    阿呆变Geek阅读 14,675评论 14赞 507
  • Java面试题整理
    Java SE 基础： 封装、继承、多态 封装： 概念：就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽...
    Jayden_Cao阅读 2,048评论 0赞 8
  • Java-Review-Note——4.多线程
    Java-Review-Note——4.多线程 标签： JavaStudy PS：本来是分开三篇的，后来想想还是整...
    coder_pig阅读 1,590评论 2赞 17
  • 浅谈Java并发编程中的若干核心技术
    作者： 一字马胡 转载标志 【2017-11-01】 更新日志 日期更新内容备注2017-11-01新建文章V1...
    一字马胡阅读 7,172评论 9赞 133
  • 代号ZJ261824.2
    人是一种很神奇的生物，在自己的生存受到威胁的时候，就会启动一种东西叫做生存本能。在那次被压成肉饼的惊险经历之...
    Shaw_Root阅读 306评论 0赞 1