Java language proposal #2
Java forces software designers to choose between synchronized and unsynchronized access when writing a class. Often, the most general-purpose design requires synchronization, while a number of important uses of the class do not. Synchronized wrapper classes are inconvenient to write and maintain; it doubles the number of classes. The designer is in a dilemma: whether to impose the performance penalty of synchronization, to write twice as many classes by providing wrappers, or to provide a less-general solution.
Java should release programmers from this dilemma by automatically creating synchronized versions of classes. The synchronized class should be a derived class of the original, containing an override for each non-final member function; the override is synchronized and forwards the invocation to the original class. Constructors of the synchronized class would be the same in signature as that of the original class, and would forward the construction to the original class's constructors. Since the synchronized version is derived from the original class, a synchronized object would be useable wherever the unsynchronized one was.
The implicit synchronized class should also be a public static nested class of the original class, with name "synchronized". Thus, to create a synchronized instance of the class HashMap, one would use "new HashMap.synchronized()" instead of "new HashMap()".
This would not break any existing code, because "synchronized" is not (and under this proposal still would not be) allowed as a programmer-defined class name. No syntax changes would be required in the language. Bytecode size need not increase significantly, as the synchronized class definition could be created on the fly.
