blocks|key|638617|text|实际上，协同例程的概念是Java线程系统的第一个设计。wait/notify机制是一种简单的共例程形式，其中notify等价于yield等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|638618|自那时以来，人们已经做了很多工作，特别是为了使结构线程安全而不是算法。这源于这样的认识:必须同步/生成的不是代码，而是用于线程之间通信的数据结构--必须是线程安全的。|638619|entityMap^0|L|3|R|4|W|6|1I|6|1R|5|0|1I|2|1W|6|0^^$0|@$1|2|3|4|5|6|7|K|8|@$9|L|A|M|B|C]|$9|N|A|O|B|D]|$9|P|A|Q|B|D]|$9|R|A|S|B|D]|$9|T|A|U|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|E|@]|F|$]]|$1|I|3|-4|5|6|7|10|8|@]|E|@]|F|$]]]|J|$]]

Actually the concept of a co-routine was the first design of the Java threading system. The <code>wait</code>/<code>notify</code> mechanism is a simplistic form of co-routine where <code>notify</code> is equivalent to <code>yield</code> etc.

Since then much has been done, particularly to make structures thread-safe rather than algorithms. This derives from the realization that it is not the code that must synchronize/yield but the data structure used to communicate between the threads that must be thread-safe.

blocks|key|467647|text|工程织机|type|unstyled|depth|inlineStyleRanges|entityRanges|data|467648|在不久的将来，延续和协同服务将出现在Java中，它们将被称为虚拟线程(也称为光纤)。有一个织机工程|offset|length|467649|Project旨在探索、培育和交付构建在其之上的Java特性和API，以支持Java平台上易于使用、高吞吐量的轻量级并发性和新的编程模型。这是通过添加以下结构来实现的：|blockquote|467650|虚拟线程|unordered-list-item|467651|定界延续|467652|尾呼消除|467653|进一步阅读：https://cr.openjdk.java.net/~rpressler/loom/Loom-Proposal.html|467654|引用该文件：|467655|该项目的目标是在Java平台中添加一个公共分隔的连续(或协同)构造。然而，这个目标仅次于光纤…。|467656|工程织机可用的初步构建，基于早期访问Java+16.|467657|entityMap|0|LINK|mutability|MUTABLE|url|https://wiki.openjdk.java.net/display/loom/Main|1|https://wiki.openjdk.java.net/display/loom/Differences%2Bbetween%2Bregular%2BThreads%2Band%2Bvirtual%2BThreads|2|https://cr.openjdk.java.net/%257Erpressler/loom/Loom-Proposal.html|3|http://jdk.java.net/loom/^0|0|19|4|0|0|0|0|4|1|0|0|0|6|1Q|2|0|0|0|0|6|3|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@$D|1D|E|1E|1|1F]]|A|$]]|$1|F|3|G|5|H|7|1G|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1H|8|@]|9|@$D|1I|E|1J|1|1K]]|A|$]]|$1|L|3|M|5|K|7|1L|8|@]|9|@]|A|$]]|$1|N|3|O|5|K|7|1M|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1N|8|@]|9|@$D|1O|E|1P|1|1Q]]|A|$]]|$1|R|3|S|5|6|7|1R|8|@]|9|@]|A|$]]|$1|T|3|U|5|H|7|1S|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1T|8|@]|9|@$D|1U|E|1V|1|1W]]|A|$]]|$1|X|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|Y|$Z|$5|10|11|12|A|$13|14]]|15|$5|10|11|12|A|$13|16]]|17|$5|10|11|12|A|$13|18]]|19|$5|10|11|12|A|$13|1A]]]]

<h1>Project Loom</h1>
Continuations and Coroutines will come to Java in the nearer future and they’ll be called virtual threads (also referred to as fibers). There’s a <a href="https://wiki.openjdk.java.net/display/loom/Main" rel="nofollow noreferrer">project called Loom</a>:
<blockquote>
Project Loom is intended to explore, incubate and deliver Java VM features and APIs built on top of them for the purpose of supporting easy-to-use, high-throughput lightweight concurrency and new programming models on the Java platform. This is accomplished by the addition of the following constructs:
<ul>
<li><a href="https://wiki.openjdk.java.net/display/loom/Differences+between+regular+Threads+and+virtual+Threads" rel="nofollow noreferrer">Virtual threads</a></li>
<li>Delimited continuations</li>
<li>Tail-call elimination</li>
</ul>
</blockquote>
Further reading: <a href="https://cr.openjdk.java.net/%7Erpressler/loom/Loom-Proposal.html" rel="nofollow noreferrer">https://cr.openjdk.java.net/~rpressler/loom/Loom-Proposal.html</a>
To quote that document:
<blockquote>
It is the goal of this project to add a public delimited continuation (or coroutine) construct to the Java platform. However, this goal is secondary to fibers …
</blockquote>
Preliminary builds of <a href="http://jdk.java.net/loom/" rel="nofollow noreferrer">Project Loom are available</a> now, based on early-access Java 16.

blocks|key|638621|text|关于“有什么计划.”问题的一部分，答案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|638622|不是在这个阶段|blockquote|638623|JEP列表(http://openjdk.java.net/jeps/0)没有提到协同。该列表涵盖了Java+8中添加的特性、为Java+9添加的特性或针对Java+9的特性，或为未来版本提出的特性。|offset|length|638624|有趣的是，2013年3月提交了一个RFE+(https://bugs.openjdk.java.net/browse/JDK-8029988)。RFE只获得一票，并在9个月内结束，并建议提交一份九月报告。对我来说，没有人费心把这个想法提得更远。|638625|entityMap|0|LINK|mutability|MUTABLE|url|http://openjdk.java.net/jeps/0|1|https://bugs.openjdk.java.net/browse/JDK-8029988^0|0|0|6|U|0|0|M|1C|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|W|8|@]|9|@$G|X|H|Y|1|Z]]|A|$]]|$1|I|3|J|5|6|7|10|8|@]|9|@$G|11|H|12|1|13]]|A|$]]|$1|K|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

On the "are there any plans ..." part of the question, the answer is:

<blockquote>
 Not at this stage
</blockquote>

The JEP list (<a href="http://openjdk.java.net/jeps/0" rel="nofollow">http://openjdk.java.net/jeps/0</a>) does not make any mention of coroutines. The list covers features added in Java 8, added or targeted for Java 9, or proposed for future releases.

Interestingly, there was an RFE submitted in March 2013 (<a href="https://bugs.openjdk.java.net/browse/JDK-8029988" rel="nofollow">https://bugs.openjdk.java.net/browse/JDK-8029988</a>). The RFE only got one vote, and it was closed 9 months with the suggestion to submit a JEP. Nobody has bothered to take the idea any further, which to me is telling.

blocks|key|640245|text|它与Java+15+build+7同步。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|640246|链接|offset|length|640247|entityMap|0|LINK|mutability|MUTABLE|url|http://mail.openjdk.java.net/pipermail/loom-dev/2020-January/001002.html^0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

It's synced with Java 15 build 7.
<a href="http://mail.openjdk.java.net/pipermail/loom-dev/2020-January/001002.html" rel="nofollow noreferrer">Link</a>

blocks|key|1221996|text|对于Java6%2B来说还有另一个选择|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1221997|化脓性协同素的实施：|1221998|import+java.lang.ref.WeakReference;
import+java.util.ArrayList;
import+java.util.List;
import+java.util.concurrent.*;
import+java.util.concurrent.atomic.AtomicBoolean;
import+java.util.concurrent.atomic.AtomicReference;

class+CorRunRAII+{
++++private+final+List<WeakReference<?+extends+CorRun>>+resources+=+new+ArrayList<>();

++++public+CorRunRAII+add(CorRun+resource)+{
++++++++if+(resource+==+null)+{
++++++++++++return+this;
++++++++}
++++++++resources.add(new+WeakReference<>(resource));

++++++++return+this;
++++}

++++public+CorRunRAII+addAll(List<?+extends+CorRun>+arrayList)+{
++++++++if+(arrayList+==+null)+{
++++++++++++return+this;
++++++++}
++++++++for+(CorRun+corRun+:+arrayList)+{
++++++++++++add(corRun);
++++++++}

++++++++return+this;
++++}

++++@Override
++++protected+void+finalize()+throws+Throwable+{
++++++++super.finalize();

++++++++for+(WeakReference<?+extends+CorRun>+corRunWeakReference+:+resources)+{
++++++++++++CorRun+corRun+=+corRunWeakReference.get();
++++++++++++if+(corRun+!=+null)+{
++++++++++++++++corRun.stop();
++++++++++++}
++++++++}
++++}
}

class+CorRunYieldReturn<ReceiveType,+YieldReturnType>+{
++++public+final+AtomicReference<ReceiveType>+receiveValue;
++++public+final+LinkedBlockingDeque<AtomicReference<YieldReturnType>>+yieldReturnValue;

++++CorRunYieldReturn(AtomicReference<ReceiveType>+receiveValue,+LinkedBlockingDeque<AtomicReference<YieldReturnType>>+yieldReturnValue)+{
++++++++this.receiveValue+=+receiveValue;
++++++++this.yieldReturnValue+=+yieldReturnValue;
++++}
}

interface+CorRun<ReceiveType,+YieldReturnType>+extends+Runnable,+Callable<YieldReturnType>+{
++++boolean+start();
++++void+stop();
++++void+stop(final+Throwable+throwable);
++++boolean+isStarted();
++++boolean+isEnded();
++++Throwable+getError();

++++ReceiveType+getReceiveValue();
++++void+setResultForOuter(YieldReturnType+resultForOuter);
++++YieldReturnType+getResultForOuter();

++++YieldReturnType+receive(ReceiveType+value);
++++ReceiveType+yield();
++++ReceiveType+yield(YieldReturnType+value);
++++<TargetReceiveType,+TargetYieldReturnType>+TargetYieldReturnType+yieldFrom(final+CorRun<TargetReceiveType,+TargetYieldReturnType>+another);
++++<TargetReceiveType,+TargetYieldReturnType>+TargetYieldReturnType+yieldFrom(final+CorRun<TargetReceiveType,+TargetYieldReturnType>+another,+final+TargetReceiveType+value);
}

abstract+class+CorRunSync<ReceiveType,+YieldReturnType>+implements+CorRun<ReceiveType,+YieldReturnType>+{

++++private+ReceiveType+receiveValue;
++++public+final+List<WeakReference<CorRun>>+potentialChildrenCoroutineList+=+new+ArrayList<>();

++++//+Outside

++++private+AtomicBoolean+isStarted+=+new+AtomicBoolean(false);
++++private+AtomicBoolean+isEnded+=+new+AtomicBoolean(false);
++++private+Throwable+error;

++++private+YieldReturnType+resultForOuter;

++++@Override
++++public+boolean+start()+{

++++++++boolean+isStarted+=+this.isStarted.getAndSet(true);
++++++++if+((!+isStarted)
++++++++++++++++&&+(!+isEnded()))+{
++++++++++++receive(null);
++++++++}

++++++++return+isStarted;
++++}

++++@Override
++++public+void+stop()+{
++++++++stop(null);
++++}

++++@Override
++++public+void+stop(Throwable+throwable)+{
++++++++isEnded.set(true);
++++++++if+(throwable+!=+null)+{
++++++++++++error+=+throwable;
++++++++}

++++++++for+(WeakReference<CorRun>+weakReference+:+potentialChildrenCoroutineList)+{
++++++++++++CorRun+child+=+weakReference.get();
++++++++++++if+(child+!=+null)+{
++++++++++++++++child.stop();
++++++++++++}
++++++++}
++++}

++++@Override
++++public+boolean+isStarted()+{
++++++++return+isStarted.get();
++++}

++++@Override
++++public+boolean+isEnded()+{
++++++++return+isEnded.get();
++++}

++++@Override
++++public+Throwable+getError()+{
++++++++return+error;
++++}

++++@Override
++++public+ReceiveType+getReceiveValue()+{
++++++++return+receiveValue;
++++}

++++@Override
++++public+void+setResultForOuter(YieldReturnType+resultForOuter)+{
++++++++this.resultForOuter+=+resultForOuter;
++++}

++++@Override
++++public+YieldReturnType+getResultForOuter()+{
++++++++return+resultForOuter;
++++}

++++@Override
++++public+synchronized+YieldReturnType+receive(ReceiveType+value)+{
++++++++receiveValue+=+value;

++++++++run();

++++++++return+getResultForOuter();
++++}

++++@Override
++++public+ReceiveType+yield()+{
++++++++return+yield(null);
++++}

++++@Override
++++public+ReceiveType+yield(YieldReturnType+value)+{
++++++++resultForOuter+=+value;
++++++++return+receiveValue;
++++}

++++@Override
++++public+<TargetReceiveType,+TargetYieldReturnType>+TargetYieldReturnType+yieldFrom(CorRun<TargetReceiveType,+TargetYieldReturnType>+another)+{
++++++++return+yieldFrom(another,+null);
++++}

++++@Override
++++public+<TargetReceiveType,+TargetYieldReturnType>+TargetYieldReturnType+yieldFrom(CorRun<TargetReceiveType,+TargetYieldReturnType>+another,+TargetReceiveType+value)+{
++++++++if+(another+==+null+%7C%7C+another.isEnded())+{
++++++++++++throw+new+RuntimeException("Call+null+or+isEnded+coroutine");
++++++++}

++++++++potentialChildrenCoroutineList.add(new+WeakReference<CorRun>(another));

++++++++synchronized+(another)+{
++++++++++++boolean+isStarted+=+another.start();
++++++++++++boolean+isJustStarting+=+!+isStarted;
++++++++++++if+(isJustStarting+&&+another+instanceof+CorRunSync)+{
++++++++++++++++return+another.getResultForOuter();
++++++++++++}

++++++++++++return+another.receive(value);
++++++++}
++++}

++++@Override
++++public+void+run()+{
++++++++try+{
++++++++++++this.call();
++++++++}
++++++++catch+(Exception+e)+{
++++++++++++e.printStackTrace();

++++++++++++stop(e);
++++++++++++return;
++++++++}
++++}
}

abstract+class+CorRunThread<ReceiveType,+YieldReturnType>+implements+CorRun<ReceiveType,+YieldReturnType>+{

++++private+final+ExecutorService+childExecutorService+=+newExecutorService();
++++private+ExecutorService+executingOnExecutorService;

++++private+static+final+CorRunYieldReturn+DUMMY_COR_RUN_YIELD_RETURN+=+new+CorRunYieldReturn(new+AtomicReference<>(null),+new+LinkedBlockingDeque<AtomicReference>());

++++private+final+CorRun<ReceiveType,+YieldReturnType>+self;
++++public+final+List<WeakReference<CorRun>>+potentialChildrenCoroutineList;
++++private+CorRunYieldReturn<ReceiveType,+YieldReturnType>+lastCorRunYieldReturn;

++++private+final+LinkedBlockingDeque<CorRunYieldReturn<ReceiveType,+YieldReturnType>>+receiveQueue;

++++//+Outside

++++private+AtomicBoolean+isStarted+=+new+AtomicBoolean(false);
++++private+AtomicBoolean+isEnded+=+new+AtomicBoolean(false);
++++private+Future<YieldReturnType>+future;
++++private+Throwable+error;

++++private+final+AtomicReference<YieldReturnType>+resultForOuter+=+new+AtomicReference<>();

++++CorRunThread()+{
++++++++executingOnExecutorService+=+childExecutorService;

++++++++receiveQueue+=+new+LinkedBlockingDeque<>();
++++++++potentialChildrenCoroutineList+=+new+ArrayList<>();

++++++++self+=+this;
++++}

++++@Override
++++public+void+run()+{
++++++++try+{
++++++++++++self.call();
++++++++}
++++++++catch+(Exception+e)+{
++++++++++++stop(e);
++++++++++++return;
++++++++}

++++++++stop();
++++}

++++@Override
++++public+abstract+YieldReturnType+call();

++++@Override
++++public+boolean+start()+{
++++++++return+start(childExecutorService);
++++}

++++protected+boolean+start(ExecutorService+executorService)+{
++++++++boolean+isStarted+=+this.isStarted.getAndSet(true);
++++++++if+(!isStarted)+{
++++++++++++executingOnExecutorService+=+executorService;
++++++++++++future+=+(Future<YieldReturnType>)+executingOnExecutorService.submit((Runnable)+self);
++++++++}
++++++++return+isStarted;
++++}

++++@Override
++++public+void+stop()+{
++++++++stop(null);
++++}

++++@Override
++++public+void+stop(final+Throwable+throwable)+{
++++++++if+(throwable+!=+null)+{
++++++++++++error+=+throwable;
++++++++}
++++++++isEnded.set(true);

++++++++returnYieldValue(null);
++++++++//+Do+this+for+making+sure+the+coroutine+has+checked+isEnd()+after+getting+a+dummy+value
++++++++receiveQueue.offer(DUMMY_COR_RUN_YIELD_RETURN);

++++++++for+(WeakReference<CorRun>+weakReference+:+potentialChildrenCoroutineList)+{
++++++++++++CorRun+child+=+weakReference.get();
++++++++++++if+(child+!=+null)+{
++++++++++++++++if+(child+instanceof+CorRunThread)+{
++++++++++++++++++++((CorRunThread)child).tryStop(childExecutorService);
++++++++++++++++}
++++++++++++}
++++++++}

++++++++childExecutorService.shutdownNow();
++++}

++++protected+void+tryStop(ExecutorService+executorService)+{
++++++++if+(this.executingOnExecutorService+==+executorService)+{
++++++++++++stop();
++++++++}
++++}

++++@Override
++++public+boolean+isEnded()+{
++++++++return+isEnded.get()+%7C%7C+(
++++++++++++++++future+!=+null+&&+(future.isCancelled()+%7C%7C+future.isDone())
++++++++++++++++);
++++}

++++@Override
++++public+boolean+isStarted()+{
++++++++return+isStarted.get();
++++}

++++public+Future<YieldReturnType>+getFuture()+{
++++++++return+future;
++++}

++++@Override
++++public+Throwable+getError()+{
++++++++return+error;
++++}

++++@Override
++++public+void+setResultForOuter(YieldReturnType+resultForOuter)+{
++++++++this.resultForOuter.set(resultForOuter);
++++}

++++@Override
++++public+YieldReturnType+getResultForOuter()+{
++++++++return+this.resultForOuter.get();
++++}

++++@Override
++++public+YieldReturnType+receive(ReceiveType+value)+{

++++++++LinkedBlockingDeque<AtomicReference<YieldReturnType>>+yieldReturnValue+=+new+LinkedBlockingDeque<>();

++++++++offerReceiveValue(value,+yieldReturnValue);

++++++++try+{
++++++++++++AtomicReference<YieldReturnType>+takeValue+=+yieldReturnValue.take();
++++++++++++return+takeValue+==+null+?+null+:+takeValue.get();
++++++++}+catch+(InterruptedException+e)+{
++++++++++++e.printStackTrace();
++++++++}

++++++++return+null;
++++}

++++@Override
++++public+ReceiveType+yield()+{
++++++++return+yield(null);
++++}

++++@Override
++++public+ReceiveType+yield(final+YieldReturnType+value)+{
++++++++returnYieldValue(value);

++++++++return+getReceiveValue();
++++}

++++@Override
++++public+<TargetReceiveType,+TargetYieldReturnType>+TargetYieldReturnType+yieldFrom(final+CorRun<TargetReceiveType,+TargetYieldReturnType>+another)+{
++++++++return+yieldFrom(another,+null);
++++}

++++@Override
++++public+<TargetReceiveType,+TargetYieldReturnType>+TargetYieldReturnType+yieldFrom(final+CorRun<TargetReceiveType,+TargetYieldReturnType>+another,+final+TargetReceiveType+value)+{
++++++++if+(another+==+null+%7C%7C+another.isEnded())+{
++++++++++++throw+new+RuntimeException("Call+null+or+isEnded+coroutine");
++++++++}

++++++++boolean+isStarted+=+false;
++++++++potentialChildrenCoroutineList.add(new+WeakReference<CorRun>(another));

++++++++synchronized+(another)+{
++++++++++++if+(another+instanceof+CorRunThread)+{
++++++++++++++++isStarted+=+((CorRunThread)another).start(childExecutorService);
++++++++++++}
++++++++++++else+{
++++++++++++++++isStarted+=+another.start();
++++++++++++}

++++++++++++boolean+isJustStarting+=+!+isStarted;
++++++++++++if+(isJustStarting+&&+another+instanceof+CorRunSync)+{
++++++++++++++++return+another.getResultForOuter();
++++++++++++}

++++++++++++TargetYieldReturnType+send+=+another.receive(value);
++++++++++++return+send;
++++++++}
++++}

++++@Override
++++public+ReceiveType+getReceiveValue()+{

++++++++setLastCorRunYieldReturn(takeLastCorRunYieldReturn());

++++++++return+lastCorRunYieldReturn.receiveValue.get();
++++}

++++protected+void+returnYieldValue(final+YieldReturnType+value)+{
++++++++CorRunYieldReturn<ReceiveType,+YieldReturnType>+corRunYieldReturn+=+lastCorRunYieldReturn;
++++++++if+(corRunYieldReturn+!=+null)+{
++++++++++++corRunYieldReturn.yieldReturnValue.offer(new+AtomicReference<>(value));
++++++++}
++++}

++++protected+void+offerReceiveValue(final+ReceiveType+value,+LinkedBlockingDeque<AtomicReference<YieldReturnType>>+yieldReturnValue)+{
++++++++receiveQueue.offer(new+CorRunYieldReturn(new+AtomicReference<>(value),+yieldReturnValue));
++++}

++++protected+CorRunYieldReturn<ReceiveType,+YieldReturnType>+takeLastCorRunYieldReturn()+{
++++++++try+{
++++++++++++return+receiveQueue.take();
++++++++}+catch+(InterruptedException+e)+{
++++++++++++e.printStackTrace();
++++++++}

++++++++return+null;
++++}

++++protected+void+setLastCorRunYieldReturn(CorRunYieldReturn<ReceiveType,YieldReturnType>+lastCorRunYieldReturn)+{
++++++++this.lastCorRunYieldReturn+=+lastCorRunYieldReturn;
++++}

++++protected+ExecutorService+newExecutorService()+{
++++++++return+Executors.newCachedThreadPool(getThreadFactory());
++++}

++++protected+ThreadFactory+getThreadFactory()+{
++++++++return+new+ThreadFactory()+{
++++++++++++@Override
++++++++++++public+Thread+newThread(final+Runnable+runnable)+{
++++++++++++++++Thread+thread+=+new+Thread(runnable);
++++++++++++++++thread.setUncaughtExceptionHandler(new+Thread.UncaughtExceptionHandler()+{
++++++++++++++++++++@Override
++++++++++++++++++++public+void+uncaughtException(Thread+thread,+Throwable+throwable)+{
++++++++++++++++++++++++throwable.printStackTrace();
++++++++++++++++++++++++if+(runnable+instanceof+CorRun)+{
++++++++++++++++++++++++++++CorRun+self+=+(CorRun)+runnable;
++++++++++++++++++++++++++++self.stop(throwable);
++++++++++++++++++++++++++++thread.interrupt();
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++});
++++++++++++++++return+thread;
++++++++++++}
++++++++};
++++}
}|code-block|syntax|javascript|1221999|现在你可以用这种方法来使用丙酮协同作用(例如斐波纳契数)。|1222000|线程版本：|1222001|class+Fib+extends+CorRunThread<Integer,+Integer>+{

++++@Override
++++public+Integer+call()+{
++++++++Integer+times+=+getReceiveValue();
++++++++do+{
++++++++++++int+a+=+1,+b+=+1;
++++++++++++for+(int+i+=+0;+times+!=+null+&&+i+<+times;+i%2B%2B)+{
++++++++++++++++int+temp+=+a+%2B+b;
++++++++++++++++a+=+b;
++++++++++++++++b+=+temp;
++++++++++++}
++++++++++++//+A+pythonic+"yield",+i.e.,+it+returns+`a`+to+the+caller+and+waits+`times`+value+from+the+next+caller
++++++++++++times+=+yield(a);
++++++++}+while+(!+isEnded());

++++++++setResultForOuter(Integer.MAX_VALUE);
++++++++return+getResultForOuter();
++++}
}

class+MainRun+extends+CorRunThread<String,+String>+{

++++@Override
++++public+String+call()+{

++++++++//+The+fib+coroutine+would+be+recycled+by+its+parent
++++++++//+(no+requirement+to+call+its+start()+and+stop()+manually)
++++++++//+Otherwise,+if+you+want+to+share+its+instance+and+start/stop+it+manually,
++++++++//+please+start+it+before+being+called+by+yieldFrom()+and+stop+it+in+the+end.
++++++++Fib+fib+=+new+Fib();
++++++++String+result+=+"";
++++++++Integer+current;
++++++++int+times+=+10;
++++++++for+(int+i+=+0;+i+<+times;+i%2B%2B)+{

++++++++++++//+A+pythonic+"yield+from",+i.e.,+it+calls+fib+with+`i`+parameter+and+waits+for+returned+value+as+`current`
++++++++++++current+=+yieldFrom(fib,+i);

++++++++++++if+(fib.getError()+!=+null)+{
++++++++++++++++throw+new+RuntimeException(fib.getError());
++++++++++++}

++++++++++++if+(current+==+null)+{
++++++++++++++++continue;
++++++++++++}

++++++++++++if+(i+>+0)+{
++++++++++++++++result+%2B=+",";
++++++++++++}
++++++++++++result+%2B=+current;

++++++++}

++++++++setResultForOuter(result);

++++++++return+result;
++++}
}|1222002|同步(非线程)版本：|1222003|class+Fib+extends+CorRunSync<Integer,+Integer>+{

++++@Override
++++public+Integer+call()+{
++++++++Integer+times+=+getReceiveValue();

++++++++int+a+=+1,+b+=+1;
++++++++for+(int+i+=+0;+times+!=+null+&&+i+<+times;+i%2B%2B)+{
++++++++++++int+temp+=+a+%2B+b;
++++++++++++a+=+b;
++++++++++++b+=+temp;
++++++++}
++++++++yield(a);

++++++++return+getResultForOuter();
++++}
}

class+MainRun+extends+CorRunSync<String,+String>+{

++++@Override
++++public+String+call()+{

++++++++CorRun<Integer,+Integer>+fib+=+null;
++++++++try+{
++++++++++++fib+=+new+Fib();
++++++++}+catch+(Exception+e)+{
++++++++++++e.printStackTrace();
++++++++}

++++++++String+result+=+"";
++++++++Integer+current;
++++++++int+times+=+10;
++++++++for+(int+i+=+0;+i+<+times;+i%2B%2B)+{

++++++++++++current+=+yieldFrom(fib,+i);

++++++++++++if+(fib.getError()+!=+null)+{
++++++++++++++++throw+new+RuntimeException(fib.getError());
++++++++++++}

++++++++++++if+(current+==+null)+{
++++++++++++++++continue;
++++++++++++}

++++++++++++if+(i+>+0)+{
++++++++++++++++result+%2B=+",";
++++++++++++}
++++++++++++result+%2B=+current;
++++++++}

++++++++stop();
++++++++setResultForOuter(result);

++++++++if+(Utils.isEmpty(result))+{
++++++++++++throw+new+RuntimeException("Error");
++++++++}

++++++++return+result;
++++}
}|1222004|执行(这两个版本都可以)：|1222005|//+Run+the+entry+coroutine
MainRun+mainRun+=+new+MainRun();
mainRun.start();

//+Wait+for+mainRun+ending+for+5+seconds
long+startTimestamp+=+System.currentTimeMillis();
while(!mainRun.isEnded())+{
++++if+(System.currentTimeMillis()+-+startTimestamp+>+TimeUnit.SECONDS.toMillis(5))+{
++++++++throw+new+RuntimeException("Wait+too+much+time");
++++}
}
//+The+result+should+be+"1,1,2,3,5,8,13,21,34,55"
System.out.println(mainRun.getResultForOuter());|1222006|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|17|8|@]|9|@]|A|$G|H]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

There's an another choice is here for Java6+

A pythonic coroutine implementation:

<pre><code>import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;

class CorRunRAII {
 private final List&lt;WeakReference&lt;? extends CorRun&gt;&gt; resources = new ArrayList&lt;&gt;();

 public CorRunRAII add(CorRun resource) {
 if (resource == null) {
 return this;
 }
 resources.add(new WeakReference&lt;&gt;(resource));

 return this;
 }

 public CorRunRAII addAll(List&lt;? extends CorRun&gt; arrayList) {
 if (arrayList == null) {
 return this;
 }
 for (CorRun corRun : arrayList) {
 add(corRun);
 }

 return this;
 }

 @Override
 protected void finalize() throws Throwable {
 super.finalize();

 for (WeakReference&lt;? extends CorRun&gt; corRunWeakReference : resources) {
 CorRun corRun = corRunWeakReference.get();
 if (corRun != null) {
 corRun.stop();
 }
 }
 }
}

class CorRunYieldReturn&lt;ReceiveType, YieldReturnType&gt; {
 public final AtomicReference&lt;ReceiveType&gt; receiveValue;
 public final LinkedBlockingDeque&lt;AtomicReference&lt;YieldReturnType&gt;&gt; yieldReturnValue;

 CorRunYieldReturn(AtomicReference&lt;ReceiveType&gt; receiveValue, LinkedBlockingDeque&lt;AtomicReference&lt;YieldReturnType&gt;&gt; yieldReturnValue) {
 this.receiveValue = receiveValue;
 this.yieldReturnValue = yieldReturnValue;
 }
}

interface CorRun&lt;ReceiveType, YieldReturnType&gt; extends Runnable, Callable&lt;YieldReturnType&gt; {
 boolean start();
 void stop();
 void stop(final Throwable throwable);
 boolean isStarted();
 boolean isEnded();
 Throwable getError();

 ReceiveType getReceiveValue();
 void setResultForOuter(YieldReturnType resultForOuter);
 YieldReturnType getResultForOuter();

 YieldReturnType receive(ReceiveType value);
 ReceiveType yield();
 ReceiveType yield(YieldReturnType value);
 &lt;TargetReceiveType, TargetYieldReturnType&gt; TargetYieldReturnType yieldFrom(final CorRun&lt;TargetReceiveType, TargetYieldReturnType&gt; another);
 &lt;TargetReceiveType, TargetYieldReturnType&gt; TargetYieldReturnType yieldFrom(final CorRun&lt;TargetReceiveType, TargetYieldReturnType&gt; another, final TargetReceiveType value);
}

abstract class CorRunSync&lt;ReceiveType, YieldReturnType&gt; implements CorRun&lt;ReceiveType, YieldReturnType&gt; {

 private ReceiveType receiveValue;
 public final List&lt;WeakReference&lt;CorRun&gt;&gt; potentialChildrenCoroutineList = new ArrayList&lt;&gt;();

 // Outside

 private AtomicBoolean isStarted = new AtomicBoolean(false);
 private AtomicBoolean isEnded = new AtomicBoolean(false);
 private Throwable error;

 private YieldReturnType resultForOuter;

 @Override
 public boolean start() {

 boolean isStarted = this.isStarted.getAndSet(true);
 if ((! isStarted)
 &amp;&amp; (! isEnded())) {
 receive(null);
 }

 return isStarted;
 }

 @Override
 public void stop() {
 stop(null);
 }

 @Override
 public void stop(Throwable throwable) {
 isEnded.set(true);
 if (throwable != null) {
 error = throwable;
 }

 for (WeakReference&lt;CorRun&gt; weakReference : potentialChildrenCoroutineList) {
 CorRun child = weakReference.get();
 if (child != null) {
 child.stop();
 }
 }
 }

 @Override
 public boolean isStarted() {
 return isStarted.get();
 }

 @Override
 public boolean isEnded() {
 return isEnded.get();
 }

 @Override
 public Throwable getError() {
 return error;
 }

 @Override
 public ReceiveType getReceiveValue() {
 return receiveValue;
 }

 @Override
 public void setResultForOuter(YieldReturnType resultForOuter) {
 this.resultForOuter = resultForOuter;
 }

 @Override
 public YieldReturnType getResultForOuter() {
 return resultForOuter;
 }

 @Override
 public synchronized YieldReturnType receive(ReceiveType value) {
 receiveValue = value;

 run();

 return getResultForOuter();
 }

 @Override
 public ReceiveType yield() {
 return yield(null);
 }

 @Override
 public ReceiveType yield(YieldReturnType value) {
 resultForOuter = value;
 return receiveValue;
 }

 @Override
 public &lt;TargetReceiveType, TargetYieldReturnType&gt; TargetYieldReturnType yieldFrom(CorRun&lt;TargetReceiveType, TargetYieldReturnType&gt; another) {
 return yieldFrom(another, null);
 }

 @Override
 public &lt;TargetReceiveType, TargetYieldReturnType&gt; TargetYieldReturnType yieldFrom(CorRun&lt;TargetReceiveType, TargetYieldReturnType&gt; another, TargetReceiveType value) {
 if (another == null || another.isEnded()) {
 throw new RuntimeException("Call null or isEnded coroutine");
 }

 potentialChildrenCoroutineList.add(new WeakReference&lt;CorRun&gt;(another));

 synchronized (another) {
 boolean isStarted = another.start();
 boolean isJustStarting = ! isStarted;
 if (isJustStarting &amp;&amp; another instanceof CorRunSync) {
 return another.getResultForOuter();
 }

 return another.receive(value);
 }
 }

 @Override
 public void run() {
 try {
 this.call();
 }
 catch (Exception e) {
 e.printStackTrace();

 stop(e);
 return;
 }
 }
}

abstract class CorRunThread&lt;ReceiveType, YieldReturnType&gt; implements CorRun&lt;ReceiveType, YieldReturnType&gt; {

 private final ExecutorService childExecutorService = newExecutorService();
 private ExecutorService executingOnExecutorService;

 private static final CorRunYieldReturn DUMMY_COR_RUN_YIELD_RETURN = new CorRunYieldReturn(new AtomicReference&lt;&gt;(null), new LinkedBlockingDeque&lt;AtomicReference&gt;());

 private final CorRun&lt;ReceiveType, YieldReturnType&gt; self;
 public final List&lt;WeakReference&lt;CorRun&gt;&gt; potentialChildrenCoroutineList;
 private CorRunYieldReturn&lt;ReceiveType, YieldReturnType&gt; lastCorRunYieldReturn;

 private final LinkedBlockingDeque&lt;CorRunYieldReturn&lt;ReceiveType, YieldReturnType&gt;&gt; receiveQueue;

 // Outside

 private AtomicBoolean isStarted = new AtomicBoolean(false);
 private AtomicBoolean isEnded = new AtomicBoolean(false);
 private Future&lt;YieldReturnType&gt; future;
 private Throwable error;

 private final AtomicReference&lt;YieldReturnType&gt; resultForOuter = new AtomicReference&lt;&gt;();

 CorRunThread() {
 executingOnExecutorService = childExecutorService;

 receiveQueue = new LinkedBlockingDeque&lt;&gt;();
 potentialChildrenCoroutineList = new ArrayList&lt;&gt;();

 self = this;
 }

 @Override
 public void run() {
 try {
 self.call();
 }
 catch (Exception e) {
 stop(e);
 return;
 }

 stop();
 }

 @Override
 public abstract YieldReturnType call();

 @Override
 public boolean start() {
 return start(childExecutorService);
 }

 protected boolean start(ExecutorService executorService) {
 boolean isStarted = this.isStarted.getAndSet(true);
 if (!isStarted) {
 executingOnExecutorService = executorService;
 future = (Future&lt;YieldReturnType&gt;) executingOnExecutorService.submit((Runnable) self);
 }
 return isStarted;
 }

 @Override
 public void stop() {
 stop(null);
 }

 @Override
 public void stop(final Throwable throwable) {
 if (throwable != null) {
 error = throwable;
 }
 isEnded.set(true);

 returnYieldValue(null);
 // Do this for making sure the coroutine has checked isEnd() after getting a dummy value
 receiveQueue.offer(DUMMY_COR_RUN_YIELD_RETURN);

 for (WeakReference&lt;CorRun&gt; weakReference : potentialChildrenCoroutineList) {
 CorRun child = weakReference.get();
 if (child != null) {
 if (child instanceof CorRunThread) {
 ((CorRunThread)child).tryStop(childExecutorService);
 }
 }
 }

 childExecutorService.shutdownNow();
 }

 protected void tryStop(ExecutorService executorService) {
 if (this.executingOnExecutorService == executorService) {
 stop();
 }
 }

 @Override
 public boolean isEnded() {
 return isEnded.get() || (
 future != null &amp;&amp; (future.isCancelled() || future.isDone())
 );
 }

 @Override
 public boolean isStarted() {
 return isStarted.get();
 }

 public Future&lt;YieldReturnType&gt; getFuture() {
 return future;
 }

 @Override
 public Throwable getError() {
 return error;
 }

 @Override
 public void setResultForOuter(YieldReturnType resultForOuter) {
 this.resultForOuter.set(resultForOuter);
 }

 @Override
 public YieldReturnType getResultForOuter() {
 return this.resultForOuter.get();
 }

 @Override
 public YieldReturnType receive(ReceiveType value) {

 LinkedBlockingDeque&lt;AtomicReference&lt;YieldReturnType&gt;&gt; yieldReturnValue = new LinkedBlockingDeque&lt;&gt;();

 offerReceiveValue(value, yieldReturnValue);

 try {
 AtomicReference&lt;YieldReturnType&gt; takeValue = yieldReturnValue.take();
 return takeValue == null ? null : takeValue.get();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }

 return null;
 }

 @Override
 public ReceiveType yield() {
 return yield(null);
 }

 @Override
 public ReceiveType yield(final YieldReturnType value) {
 returnYieldValue(value);

 return getReceiveValue();
 }

 @Override
 public &lt;TargetReceiveType, TargetYieldReturnType&gt; TargetYieldReturnType yieldFrom(final CorRun&lt;TargetReceiveType, TargetYieldReturnType&gt; another) {
 return yieldFrom(another, null);
 }

 @Override
 public &lt;TargetReceiveType, TargetYieldReturnType&gt; TargetYieldReturnType yieldFrom(final CorRun&lt;TargetReceiveType, TargetYieldReturnType&gt; another, final TargetReceiveType value) {
 if (another == null || another.isEnded()) {
 throw new RuntimeException("Call null or isEnded coroutine");
 }

 boolean isStarted = false;
 potentialChildrenCoroutineList.add(new WeakReference&lt;CorRun&gt;(another));

 synchronized (another) {
 if (another instanceof CorRunThread) {
 isStarted = ((CorRunThread)another).start(childExecutorService);
 }
 else {
 isStarted = another.start();
 }

 boolean isJustStarting = ! isStarted;
 if (isJustStarting &amp;&amp; another instanceof CorRunSync) {
 return another.getResultForOuter();
 }

 TargetYieldReturnType send = another.receive(value);
 return send;
 }
 }

 @Override
 public ReceiveType getReceiveValue() {

 setLastCorRunYieldReturn(takeLastCorRunYieldReturn());

 return lastCorRunYieldReturn.receiveValue.get();
 }

 protected void returnYieldValue(final YieldReturnType value) {
 CorRunYieldReturn&lt;ReceiveType, YieldReturnType&gt; corRunYieldReturn = lastCorRunYieldReturn;
 if (corRunYieldReturn != null) {
 corRunYieldReturn.yieldReturnValue.offer(new AtomicReference&lt;&gt;(value));
 }
 }

 protected void offerReceiveValue(final ReceiveType value, LinkedBlockingDeque&lt;AtomicReference&lt;YieldReturnType&gt;&gt; yieldReturnValue) {
 receiveQueue.offer(new CorRunYieldReturn(new AtomicReference&lt;&gt;(value), yieldReturnValue));
 }

 protected CorRunYieldReturn&lt;ReceiveType, YieldReturnType&gt; takeLastCorRunYieldReturn() {
 try {
 return receiveQueue.take();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }

 return null;
 }

 protected void setLastCorRunYieldReturn(CorRunYieldReturn&lt;ReceiveType,YieldReturnType&gt; lastCorRunYieldReturn) {
 this.lastCorRunYieldReturn = lastCorRunYieldReturn;
 }

 protected ExecutorService newExecutorService() {
 return Executors.newCachedThreadPool(getThreadFactory());
 }

 protected ThreadFactory getThreadFactory() {
 return new ThreadFactory() {
 @Override
 public Thread newThread(final Runnable runnable) {
 Thread thread = new Thread(runnable);
 thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
 @Override
 public void uncaughtException(Thread thread, Throwable throwable) {
 throwable.printStackTrace();
 if (runnable instanceof CorRun) {
 CorRun self = (CorRun) runnable;
 self.stop(throwable);
 thread.interrupt();
 }
 }
 });
 return thread;
 }
 };
 }
}
</code></pre>

Now you can use pythonic coroutines in this way
(e.g. fibonacci numbers)

Thread Version:

<pre><code>class Fib extends CorRunThread&lt;Integer, Integer&gt; {

 @Override
 public Integer call() {
 Integer times = getReceiveValue();
 do {
 int a = 1, b = 1;
 for (int i = 0; times != null &amp;&amp; i &lt; times; i++) {
 int temp = a + b;
 a = b;
 b = temp;
 }
 // A pythonic "yield", i.e., it returns `a` to the caller and waits `times` value from the next caller
 times = yield(a);
 } while (! isEnded());

 setResultForOuter(Integer.MAX_VALUE);
 return getResultForOuter();
 }
}

class MainRun extends CorRunThread&lt;String, String&gt; {

 @Override
 public String call() {

 // The fib coroutine would be recycled by its parent
 // (no requirement to call its start() and stop() manually)
 // Otherwise, if you want to share its instance and start/stop it manually,
 // please start it before being called by yieldFrom() and stop it in the end.
 Fib fib = new Fib();
 String result = "";
 Integer current;
 int times = 10;
 for (int i = 0; i &lt; times; i++) {

 // A pythonic "yield from", i.e., it calls fib with `i` parameter and waits for returned value as `current`
 current = yieldFrom(fib, i);

 if (fib.getError() != null) {
 throw new RuntimeException(fib.getError());
 }

 if (current == null) {
 continue;
 }

 if (i &gt; 0) {
 result += ",";
 }
 result += current;

 }

 setResultForOuter(result);

 return result;
 }
}
</code></pre>

Sync(non-thread) version:

<pre><code>class Fib extends CorRunSync&lt;Integer, Integer&gt; {

 @Override
 public Integer call() {
 Integer times = getReceiveValue();

 int a = 1, b = 1;
 for (int i = 0; times != null &amp;&amp; i &lt; times; i++) {
 int temp = a + b;
 a = b;
 b = temp;
 }
 yield(a);

 return getResultForOuter();
 }
}

class MainRun extends CorRunSync&lt;String, String&gt; {

 @Override
 public String call() {

 CorRun&lt;Integer, Integer&gt; fib = null;
 try {
 fib = new Fib();
 } catch (Exception e) {
 e.printStackTrace();
 }

 String result = "";
 Integer current;
 int times = 10;
 for (int i = 0; i &lt; times; i++) {

 current = yieldFrom(fib, i);

 if (fib.getError() != null) {
 throw new RuntimeException(fib.getError());
 }

 if (current == null) {
 continue;
 }

 if (i &gt; 0) {
 result += ",";
 }
 result += current;
 }

 stop();
 setResultForOuter(result);

 if (Utils.isEmpty(result)) {
 throw new RuntimeException("Error");
 }

 return result;
 }
}
</code></pre>

<hr>

Execution(Both versions will work):

<pre><code>// Run the entry coroutine
MainRun mainRun = new MainRun();
mainRun.start();

// Wait for mainRun ending for 5 seconds
long startTimestamp = System.currentTimeMillis();
while(!mainRun.isEnded()) {
 if (System.currentTimeMillis() - startTimestamp &gt; TimeUnit.SECONDS.toMillis(5)) {
 throw new RuntimeException("Wait too much time");
 }
}
// The result should be "1,1,2,3,5,8,13,21,34,55"
System.out.println(mainRun.getResultForOuter());
</code></pre>

I am reading this page about <a href="http://www.informit.com/articles/article.aspx?p=2320938" rel="noreferrer">coroutines in Python</a> and this <a href="https://en.wikipedia.org/wiki/Coroutine" rel="noreferrer">Wikipedia page.</a> I saw that there are a few <a href="https://stackoverflow.com/questions/2846428/available-coroutine-libraries-in-java">libraries in Java</a> implementing coroutines. 

My question is: is there any known reason why the Java designers decided not to implement coroutines so far and is there any plan to include it in a future version of Java?

Thanks.

Coroutines in Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我正在阅读关于和的这一页，我看到有几个实现协同。我的问题是:到目前为止，Java设计人员决定不实现协同机制是否有任何已知的原因，是否有计划将其包括在Java的未来版本中？谢谢。

问Java中的协同服务
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的协同服务EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的协同服务
EN