同时支持抢占式和协作式线程的能力在某些服务器应用程序中是基本要求，尤其是在想使系统达到最高性能的情况下。我认为
Java 编程语言在简化线程模型上走得太远了，并且 Java 编程语言应支持
Posix/Solaris 的“绿色(green)线程”和“轻便(lightweight)进程”概念（在“（Taming Java Threads”第一章中讨论）。
这就是说，有些 Java 虚拟机的实现（例如在 NT 上的 Java 虚拟机）应在其内部仿真协作式进程，其它
Java 虚拟机应仿真抢占式线程。而且向 Java 虚拟机加入这些扩展是很容易的。



一个 Java 的 Thread 应始终是抢占式的。这就是说，一个 Java 编程语言的线程应像 Solaris
的轻便进程一样工作。 Runnable 接口可以用于定义一个 Solaris 式的“绿色线程”，此线程必需能把控制权转给运行
在相同轻便进程中的其它绿色线程。




例如，目前的语法：




class My_thread implements Runnable
{ public void run(){ /*...*/ }
}

new Thread( new My_thread );





能有效地为 Runnable 对象产生一个绿色线程，并把它绑定到由
Thread 对象代表的轻便进程中。这种实现对于现有代码是透明的，因为它的有效性和现有的完全一样。


把 Runnable 对象想成为绿色线程，使用这种方法，只需向
Thread 的构造函数传递几个 Runnable对象，就可以扩展
Java 编程语言的现有语法，以支持在一个单一轻便线程有多个绿色线程。（绿色线程之间可以相互协作，但是它们可被运行在其它轻便进程
(Thread 对象) 上的绿色进程(Runnable 对象) 抢占。）。例如，下面的代码会为每个
runnable 对象创建一个绿色线程，这些绿色线程会共享由 Thread 对象代表的轻便进程。


new Thread( new My_runnable_object(), new My_other_runnable_object() );





现有的覆盖(override) Thread 对象并实现 run() 的习惯继续有效，但是它应映射到一个被绑定到一轻便进程的绿色线程。(在
Thread() 类中的缺省 run() 方法会在内部有效地创建第二个 Runnable 对象。)

线程间的协作

应在语言中加入更多的功能以支持线程间的相互通信。目前，PipedInputStream
和 PipedOutputStream 类可用于这个目的。但是对于大多数应用程序，它们太弱了。我建议向
Thread 类加入下列函数：


增加一个 wait_for_start() 方法，它通常处于阻塞状态，直到一个线程的
run() 方法启动。(如果等待的线程在调用 run 之前被释放，这没有什么问题）。用这种方法，一个线程可以创建一个或多个辅助线程，并保证在创建线程继续执行操作之前，这些辅助线程会处于运行状态。


（向 Object 类）增加 $send (Object o) 和 Object=$receive()
方法，它们将使用一个内部阻断队列在线程之间传送对象。阻断队列应作为第一个
$send() 调用的副产品被自动创建。 $send() 调用会把对象加入队列。
$receive() 调用通常处于阻塞状态，直到有一个对象被加入队列，然后它返回此对象。这种方法中的变量应支持设定入队和出队的操作超时能力：
$send (Object o, long timeout)
和 $receive (long timeout)。



对于读写锁的内部支持

读写锁的概念应内置到 Java 编程语言中。读写器锁在“Taming Java Threads”（和其它地方）中有详细讨论，概括地说：一个读写锁支持多个线程同时访问一个对象，但是在同一时刻只有一个线程可以修改此对象，并且在访问进行时不能修改。读写锁的语法可以借用 synchronized 关键字：

static Object global_resource;

//...

public void a()
{
$reading( global_resource )
{ // While in this block, other threads requesting read
// access to global_resource will get it, but threads
// requesting write access will block.
}
}

public void b()
{
$writing( global_resource )
{ // Blocks until all ongoing read or write operations on
// global_resource are complete. No read or write
// operation or global_resource can be initiated while
// within this block.
}
}

public $reading void c()
{ // just like $reading(this)...
}

public $writing void d()
{ // just like $writing(this)...
}





对于一个对象，应该只有在 $writing 块中没有线程时，才支持多个线程进入
$reading 块。在进行读操作时，一个试图进入 $writing
块的线程会被阻断，直到读线程退出 $reading
块。 当有其它线程处于 $writing 块时，试图进入 $reading
或 $writing 块的线程会被阻断，直到此写线程退出 $writing
块。



如果读和写线程都在等待，缺省情况下，读线程会首先进行。但是，可以使用
$writer_priority 属性修改类的定义来改变这种缺省方式。如：



$write_priority class IO
{
$writing write( byte[] data )
{ //...
}

$reading byte[] read( )
{ //...
}
}


访问部分创建的对象应是非法的

当前情况下，JLS 允许访问部分创建的对象。例如，在一个构造函数中创建的线程可以访问正被创建的对象，既使此对象没有完全被创建。下面代码的结果无法确定：


class Broken
{ private long x;

Broken()
{ new Thread()
{ public void run()
{ x = -1;
}
}.start();

x = 0;
}
}




设置 x 为 -1 的线程可以和设置 x 为 0 的线程同时进行。所以，此时 x 的值无法预测。


对此问题的一个解决方法是，在构造函数没有返回之前，对于在此构造函数中创建的线程，既使它的优先级比调用
new 的线程高，也要禁止运行它的 run() 方法。




这就是说，在构造函数返回之前， start()
请求必须被推迟。

另外，Java 编程语言应可允许构造函数的同步。换句话说，下面的代码（在当前情况下是非法的）会象预期的那样工作：

class Illegal
{ private long x;

synchronized Broken()
{ new Thread()
{ public void run()
{ synchronized( Illegal.this )
{
x = -1;
}
}
}.start();

x = 0;
}
}






我认为第一种方法比第二种更简洁，但实现起来更为困难。


volatile
关键字应象预期的那样工作

JLS 要求保留对于 volatile 操作的请求。大多数 Java 虚拟机都简单地忽略了这部分内容，这是不应该的。在多处理器的情况下，许多主机都出现了这种问题，但是它本应由
JLS 加以解决的。如果您对这方面感兴趣，马里兰大学的 Bill Pugh
正在致力于这项工作（请参阅参考资料）。