Growing a Developer - Svetlin Nakov @ BHRMDA Conference 2012
Java 7 – New Features Svetlin Nakov, Mihail Stoynov Bulgarian Association of Software Developers ...
Transcript of Java 7 – New Features Svetlin Nakov, Mihail Stoynov Bulgarian Association of Software Developers ...
Java 7 – New FeaturesSvetlin Nakov, Mihail StoynovSvetlin Nakov, Mihail StoynovBulgarian Association of Software DevelopersBulgarian Association of Software Developers
www.devbg.orgwww.devbg.orgBGJUG, TU-Sofia, hall 214020.05.2010BGJUG, TU-Sofia, hall 214020.05.2010
About the Speakers
• Svetlin Nakov• 15+ years software engineering
experience• PhD in computer science from Sofia
University• Chairman of the Bulgarian Association
of Software Developers (BASD) – www.devbg.org
• Author of 6 books about Java, .NET and software engineering
• Blog: www.nakov.com/blog/
About the Speakers (2)
• Mihail Stoynov• Dev Lead, Materna Bulgaria
• Many years software engineering experience with Java, .NET and others
• Blog: http://mihail.stoynov.com/blog/
Table of Contents
• Java 7 – Introduction and Chronology• Dynamic Languages in JVM• Java Modularity – Project Jigsaw• Language Enhancements (Project Coin)• Closures for Java• JSR 203: NIO 2• Other new features:
• Compressed 64-bit oops, Garbage-First GC, Upgraded Class-Loaders, URLClassLoader. close(), Unicode 5.1, SCTP and SDP
Introduction and Chronology
OpenJDK
• JDK7 is the second JDK done via the
OpenJDK effort
• OpenJDK is free, open-source and GPL
licensed
• A lot of the improvements of JDK7 are
separate projects on OpenJDK
• Some say that projects go under the cap of
OpenJDK to avoid the cumbersome and slow
JCP process
Java 7 – Milestones
• Began in August 2006• First supposed to be 7 milestones• Mark Reinhold extended them to 10• Current status: M7 finished, presentation
made with build89• M10 expected to finish 09.09.2010
“The last scheduled milestone cycle will be followed by a test and stabilization period of indeterminate length, after which the final release will be declared”
There’s No JSR Yet
• A Java 7 JSR is supposed to be formed
• Java SE 6 was under the 'Umbrella' JSR 270
• JDK7 is in Eclipse’s low priority list because a
lack of container JSR
• JDK7 cannot be finalized without a JSR
• There are some functionalities that also lack a JSR
• While doing this presentation we used the
term JSR TBD in lieu of the missing JSR
Source Control System
• Official SCM is SVN, still
• Note: it takes a 'while' (e.g. one night)
• Unofficial Mercurial forest repositories available since November 2007
• Note: this also takes a 'while'
>svn co https://jdk7.dev.java.net/svn/jdk7/trunk
>hg fclone http://hg.openjdk.java.net/
Currently Supported IDEs
• Eclipse• Both Eclipse 3.6M6 and E4 do not support
JDK7’s syntax
• … or I couldn’t figure it out
• Strangely enough the option is there:
• Source compatibility: 1.7
• NetBeans• 6.9 Beta supports JDK7
• Compiles successfully the M7 syntax
Dynamic Languages in JVM
The Da Vinci Machine Project
• Prototype a number of extensions to the JVM• A.k.a. Multi Language Virtual Machine –
http://openjdk.java.net/projects/mlvm/
• Allows non-Java dynamic languages to run efficiently in the JVM
• Emphasis is on general purpose extensions
• Hosted on OpenJDK
Da Vinci: a multi-language renaissancefor the Java Virtual Machine architecture
Dynamic Languages in JVM
• Da Vinci Machine sub-projects include:• Dynamic invocation
• Continuations
• Tail-calls
• And interface injection
• JSR 292: Supporting Dynamically Typed Languages on the Java Platform• The standard behind Da Vinci Machine
• Natural continuation of JSR 223: Scripting for the Java Platform implemented in JDK 6
Dynamic Languages in JVM (2)
• New JVM instruction invokedynamic• Allows extremely fast dynamic method
invocation through method handles
• Will enable JRuby, Jython, Groovy and other dynamic and scripting languages to call dynamic methods natively at bytecode level
• Method handles• Lightweight references to a method – java.dyn.MethodHandle
• Anonymous classes in the JVM
Dynamic Languages in JVM (3)
• Autonomous methods• Methods that can be dynamically attached to
an existing class at runtime
• Interface injection• Acquiring base interfaces and method
implementations at runtime
• Continuations and stack introspection • Suspend / resume thread's execution stack
• Tail calls and tail recursion
Dynamic Languages in JVM (4)
• Runtime support for closures• Closure is a lambda-expression bound
(closed) to its environment
• Multimethods• Dispatch a method overload depending on the
actual arguments at runtime
• Faster reflection and faster interface invocation based on dynamic invocation
• Symbolic freedom for identifier names
Dynamic Invoke – Example
static void greeter(String x) { System.out.println("Hello, " + x);}
static MethodHandle greeterMethodHandle = MethodHandles.lookup().findStatic( DynamicInvocation.class, "greeter", MethodType. methodType(void.class, String.class));
static { Linkage.registerBootstrapMethod( "bootstrapDynamic");}
Dynamic Invoke – Example (2)
private static CallSite bootstrapDynamic( Class caller, String name, MethodType type) { if (type.parameterCount() == 1 && name == "hail") { MethodHandle target = MethodHandles. convertArguments(greeterMethodHandle, type); CallSite site = new CallSite(caller, name, type); site.setTarget(target); System.out.println("Set the CallSite target to " + greeterMethodHandle); return site; }}
public static void main(String... args) { InvokeDynamic.hail("dynamic invocation");}
Java ModularityProject Jigsaw
Modularization – Introduction
• The JDK and the JRE, have always been delivered as massive, indivisible artifacts
• The growth of the platform has thus inevitably led to the growth of the basic JRE download• which now stands at well over 14MB
• despite heroic engineering efforts such as the Pack200 class file compression format
• Java Kernel and Quickstarter features do improve download time and startup time, at least for Windows users
The Real Solution
• The most promising way to improve the key metrics of• Download time
• Startup time
• And memory footprint
• Is to attack the root problem head-on:• Divide the JDK into a set of well specified and
separate, yet interdependent, modules
• A side effect is that JAR format has to reworked
Alan Bateman: It’s Difficult
• Suppose you are using the Logging API• Logging requires NIO (for file locking)
• And JMX (as loggers are managed)
• JMX requires JavaBeans, JNDI, RMI and CORBA (JMX remote API mandates that the RMI connector support both JRMP and IIOP)
• JNDI requires java.applet.Applet (huh?) and JavaBeans has dependencies on AWT, Swing
• Not satisfied with this, JavaBeans has persistent delegates that create dependencies on JDBC and more
How to Do It?
• Modularizing the JDK requires a module system capable of supporting such an effort
• It requires, in particular, a module system whose core can be implemented directly within the Java virtual machine
• Modularizing is best done with a module system that’s tightly integrated with the Java language• Otherwise the compile-time module
environment can differ dramatically from the run-time module environment
Which Module System?
• JSR 277 proposes the JAM module system
• Some of its rich, non-declarative features would be impossible to implement its core functionality directly within the JVM
• Therefore Sun halted the development
• JSR 294 is chartered to extend the language and JVM to support modular programming
• Well received for its simplicity and its utility to existing module systems such as OSGi
Which Module System? (2)
• OSGi
• May 2007: OSGi 4.1 standardized as JSR-291
• Reasonably mature, stable, and robust
• Implemented within Apache Harmony JVM
• Not at all integrated with the Java language
• Jigsaw created to modularize JDK7
• Will not be an official part of the Java SE 7 Platform Specification and might not be supported by other SE 7 implementations
Status and Examples
• Probably JSR 294 will be chosen• There are issues, JSR 294 is inactive (paused)
• Not implemented yet (b89), java.lang.module
• Example (may, and probably will, change)module [email protected] provides [email protected], [email protected] { requires [email protected], [email protected]; permits M6; // only M6 can depend on M1}
module M;package P;public class Foo {...}
JSR 308:(Extended) Annotations
on Java Types
JSR 308 – Introduction
• Java SE 6 permits annotations only on declarations
• JSR 308 extends Java’s annotation system so that annotations may appear on nearly any use of a type• JSR 308 is backward-compatible and
continues to permit those annotations
• Two new types of annotations (target wise):• ElementType.TYPE_USE• ElementType.TYPE_PARAMETER
JSR 308: Examples
public static void main() { //for generic type arguments in a generic method JSR308Example2.<@NonNull String>method("...");
//for type parameters and type parameter bounds: Collection<@Long ? super @Existing File> c = null;
//for class inheritance: class UnmodifiableList<T> implements @Readonly List<@Readonly T> { }}
//for throws clauses:void monitorTemperature() throws @Critical Exception {}
//for method receivers:public String toString() @Readonly { return null; }
// helper onlypublic static <T> T method(String s) {return null;}
Small Language Enhancements (Project Coin)
Project Coin – Introduction
• Project Coin unites all language changes to the Java Lang Specification (JLS) to be added to JDK 7
• Open call for proposals• From February 27, 2009
• Through March 30, 2009
• 70 proposal forms
• 9 were chosen
• No Milestone selected yet (so not all features are available)
The Chosen Ones
• Strings in Switch• By Joseph D. Darcy
• Automatic Resource Management• By Joshua Bloch
• Improved Type Inference for Generic Instance Creation• By Jeremy Manson
• Simplified Varargs Method Invocation• By Bob Lee
The Chosen Ones (2)
• Collection Literals• By Joshua Bloch
• Indexing access syntax for Lists and Maps• By Shams Mahmood
• Language support for JSR 292• By John Rose
• Binary Literals
• Underscores in numbers• By Derek Foster
1. Strings in Switch
Strings in Switch
• Syntactic sugar
// Finally! - strings in switchString s = "";switch (s) { case "Edno": out.println("1"); break; case "Dve": out.println("2"); break; default: out.println("Unknown BG number."); break;}
2. Automatic Resource Management (ARM)
ARM – The Problem
• A resource is as an object that must be closed manually• InputStream, Reader, Writer, DB
connection
• Manual resource termination has proven ugly and error prone• Even good programmers get it wrong
• Resource leaks or even outright failures, which may be silent
• If an exception is thrown in the try block, and in the finally block, the second supplants the first
ARM – The Problem (2)
• Where’s the problem with this code?
• If an exception is thrown in the try block, and in the finally block, the second supplants the first
• Was "Text" written successfully?
BufferedWriter br = new BufferedWriter(new FileWriter(path));
try { br.write("Text");} finally { br.close();}
How It’s Done (One Resource)
BufferedWriter br = new BufferedWriter(new FileWriter(path));
try { // This exception is more important br.write("Text");} finally { try { // ... than this one br.close(); } catch(IOException ioe) {}}
• Try-finally – with one resource:
How It’s Done (Two Resources)
static void copy(String src, String dest) throws IOException { InputStream in = new FileInputStream(src); try { OutputStream out = new FileOutputStream(dest); try { byte[] buf = new byte[8 * 1024]; int n; while ((n = in.read(buf)) >= 0) out.write(buf, 0, n); } finally { try { out.close(); } catch(IOException ioe) {} } } finally { try { in.close(); } catch(IOException ioe) {} }}
• Code is now 4 lines• Removed the boring nested try, catch, finally, close() clauses
• The first exception is thrown if a problem occurs, the close() exception is hidden
ARM Syntax – Two Resources
static void copy(String src, String dest) throws IOException { try (InputStream in = new FileInputStream(src); OutputStream out = new FileOutputStream(dest)) { byte[] buf = new byte[8192]; int n; while ((n = in.read(buf)) >= 0) out.write(buf, 0, n); }}
Automatic Resource Management
• ARM statement is a form of the try statement that declares one or more resources
• The scope of these resource declarations is
limited to the statement
• When the statement completes, whether
normally or abruptly, all of its resources are
closed automatically
• As of b89 ARM is not yet available, but definitely going to be inside JDK7
An Interface Must be Chosen
• A class must implement a designated interface to make it eligible for automatic resource management
• An obvious choice would be Closeable• close() method throws IOException• What about general purpose resources?
package java.io;
import java.io.IOException;
public interface Closeable { public void close() throws IOException;}
An Interface Must be Chosen (2)
• It is possible to retrofit Closeable with a parameterized superinterface
• Disposable would become:
package java.lang;
public interface Disposable<X extends Throwable> { void close() throws X;}
package java.io;
import java.io.IOException;
public interface Closeable extends Disposable<IOException> { void close() throws IOException;}
ARM – Notes
• No interface is chosen, nor implemented yet
• As of b89
• Migration
• Any resource that must be closed manually should be retrofitted to implement the Disposable interface
• In the JDK, this includes:
• Closeable (all streams implement it)
• Connection, Statement, and ResultSet
Suppressed Exceptions
• ARM discards suppressed exceptions
• Proposal implies they can be saved by adding them in suppressing exception via two new methods to Throwable:
• void addSuppressedException(Throwable)
• Throwable[]getSuppressedExceptions()
• As of b89 not implemented and it’s not clear whether they will be
3. Improved Type Inference for Generic
Instance Creation
What is the Fuss All About?
• Simply this:
• … becomes:
• <> is called the ‘diamond‘• Cannot be omitted because no difference can
be made between raw HashMap and a parameterized one
• [Ctrl+Shift+F] fails on diamond in NetBeans 6.9
• Implemented in b89
Map<String, List<String>> anagrams = new HashMap<String, List<String>>();
Map<String, List<String>> anagrams = new HashMap<>();
Diamond <>: Advanced Example
• This is supposed to work:
• …but does not yet (as of b89)
public class AdvancedExample {
public static void main() { method("", new ArrayList<>(), new ArrayList<>()); }
public static <T> T method(T a, List<T> b, List<Map<T, T>> c) {
return a; }}
4. Simplified Varargs Method
Invocation
Simplified Varargs Method…
• The compiler currently generates an "unsafe operation" warning• When a programmer tries to invoke a varargs
method with a non-reifiable varargs type
• JDK 7 will move the warning from the call site to the method declaration
• Major advantages• Reduces the total number of warnings
reported to and suppressed by programmers
A Picture is Worth a 1000 Words
/** NOT WORKING in b89, no change with jdk1.6.0_20 */public static void main() { Callable<String> t = null;
//OLD: Warning: "uses unchecked or unsafe operations“ List<Callable<String>> merged = asList(t);
System.out.println(merged);}
// NEW: Warning: "unchecked generic array creation"private static <T> List<T> asList(T... elements ) { return Arrays.asList(elements);}
Simplified Varargs – Example
interface Sink<T> { void add(T... a);}
/** NOT WORKING in b89, no change with jdk1.6.0_20 */interface BrokenSink<T> extends Sink<T> { // OLD: no warning // NEW: Warning: "Overriddes non-reifiable varargs type with array" void add(T[] a);}
/** NOT WORKING in b89, no change with jdk1.6.0_20 */class StringSink implements Sink<String> { // OLD: no warning // NEW: Warning: "override generates a more specific varargs type erasure" public void add(String... a) {}}
5. Collection Literals
Collection Literals
• Again a syntax sugar
• Not yet available, so no demo
/** NOT WORKING in b89 */public static void main(String... args) {
List<String> list = ["One", "Two"];
Set<String> set = {"One", "Two", "Three"};
Map<String, Integer> map = {"One" : 1, "Two" : 2};
// Note: Object s = { }; // empty set; Object m = {:}; // empty map;}
6. Indexing Access Syntax for Lists
and Maps
Collection Indexers
• Syntax sugar
/** NOT WORKING in b89 */public static void main(String... args) { List<String> list = Arrays.asList(new String[]{"a", "b", "c"}); Map<Integer, String> map = new HashMap<Integer, String>(4);
// THE OLD WAY String firstElement = list.get(0); map.put(1, "One"); // THE NEW WAY (NOT IMPLEMENTED YET) String firstElement = list[0]; map[1] = "One";}
7. Language Support for JSR 292
JSR 292 Support in javac
• java.dyn.InvokeDynamic will accept any method call and turn it into an invokedynamic instruction
• The type java.dyn.MethodHandle will accept any argument and return types
• Bytecode names acceptable to the JVM can be spelled from Java code, using #" "
• java.dyn.InvokeDynamic serves as a bare reference type: anything implicitly converts to it
• It can be cast to anything, but it is not a subtype of java.lang.Object
JSR 292 – Example
// Works in b89// type (Object, int) -> booleanboolean z = java.dyn.InvokeDynamic.<boolean>myEquals(x, y);
// Works in b89MethodHandle hndl = MethodHandles.lookup().findVirtual( PrintStream.class, "println", MethodType.methodType( void.class, String.class));
hndl.invokeGeneric(System.out, "Merhaba");
// Works in b89String #"g 1 $!$#%" = "Text";System.out.println(#"g 1 $!$#%");
9. Underscores in Numbers
Underscores in Numbers
/** WORKING in b89 */public static void main(String... args) {
// THE OLD WAY int oldBillion = 1000000000;
// THE NEW WAY int newBillion = 1_000_000_000;
out.println(oldBillion); out.println(newBillion);}
• Too much sugar can cause diabetes
• May seem useless, but don’t judge too quickly
10. Binary Literals
Binary Literals
/** WORKING in b89 */public static void main(String... args) { // THE OLD WAY int oldBinary1 = 153; int oldBinary2 = 128 ^ 0 ^ 0 ^ 16 ^ 8 ^ 0 ^ 0 ^ 1;
// THE NEW WAY int newBinary = 0b1001_1001; out.println(oldBinary1); out.println(oldBinary2); out.println(format("[0b1001_1001] is {0}", newBinary));}
• The syntax is 0b11110000;
• See where underscores come in handy?
Closures in JavaFirst-class Functions, Function Types and Lambda Expressions
What are Closures?
• Closures – definition• Closures are functions that are evaluated in
an environment containing one or more bound variables [Wikipedia]
• In English: a little snippet of code (function) that can be passed as argument of some method for subsequent execution
• Closures come from functional programming languages like Lisp
• Limited support for closures since JDK 1.1, in the form of anonymous classes
First-class and Anonymous Functions
• First-class functions are programming paradigm that supports• Data structure holding a function with its
parameters and return type
• Passing functions as arguments to other functions and invoking them
• Returning functions as result
• Anonymous functions• Functions without name (lambda functions)
• Take some parameters and return a value
Lambda Expressions
• Lambda calculus• A formal mathematical system for function
definition, function application and recursion
• Typed and untyped lambda calculus
• Lambda expressions• Anonymous functions that take parameters
and return values, e.g.
• x → x*x
• (x, y) → x*x + y*y
• A.k.a. lambda functions
Project Lambda
• Project Lambda• Goals
• To formulate a proposal to add first-class functions, function types, and lambda expressions (informally, "closures") to Java
• To implement a prototype suitable for inclusion in JDK 7
• Official Web Site• http://openjdk.java.net/projects/lambda/
• Status• Straw-man proposal, still no JSR
Lambda Expressions in Java
• Lambda expressions in Java use the # syntax• Function with no arguments, returns 42:
• Function with int argument:
• Function with two int arguments:
#()(42)
#(int x)(x + x)
#(int x, int y)(x * y)
Lambda Expressions with Code Block
• Lambda expressions can have body• A Java code block:
#(int x, int y) { int z = (int)Math.sqrt(x*x + y*y); if (z < 10) return x; else if (z > 10) return y; else return 0;}
Function Types
• Function types are data types that hold a reference to lambda function or method:
• Functions stored in variable of function type can be invoked like any other function:
#int() fortyTwo = #()(42);#int(int) triple = #(int x)(3*x); #int(int,int) mult = #(int x, int y)(x * y);
System.out.println(fortyTwo());int result = triple(5);int multResult = mult(3, 5);
Functions as Arguments
• Lambda functions can be passed as arguments to a method
public long sum(int[] arr, #int(int) fn) { long sum = 0; for (int element : arr) sum += fn(element); return sum;}
int[] arr = new int[] {1, 2, 3, 4};long squaresSum = sum(arr, #(int x)(x*x));System.out.println(squaresSum); // 30
Functions as Return Value
• Lambda functions can be returned as result of method execution:
public #int(int) adder(int c) { return #(int x)(x + c);}
#int(int) a42 = adder(42);System.out.println(a42(2)); // 44
Function Conversions
• Lambda functions can be converted to abstract class / interface defining a single method:
Thread th = new Thread(new Runnable() { public void run() { doSomeStuff(); doMoreStuff(); } });
Thread th = new Thread(#(){ doSomeStuff(); doMoreStuff(); } )
Variable Capture
• We can share local state between the body of a lambda expression and its enclosing scope• A new keyword shared is introduced
shared int comparisonsCount = 0;Collections.sort(data, #(String a, String b) { comparisonsCount++; return a.compareTo(b);});
System.out.println(comparisonsCount);
Instance Capture
• The this reference of the enclosing class could be accessed in a lambda expression:
class CountingSorter { private int comparisonsCount = 0; Collections.sort(data, #(String a, String b) { comparisonsCount++; return a.compareTo(b); });
Extension Methods
• Extension methods allow the author of an existing interface to add methods to that interface while preserving compatibility
• For example, we need to add a method for filtering members from any collection by given Boolean condition:
Set<Integer> set = new Set<Integer>(new int[] {1,2,3,4,5});Set<Integer> filteredSet = set.filter(#boolean(int x)(x < 3));
Extension Methods (2)
• Defining extension methods:
class Collections { … static <T> Set<T> filter( Set<T> s, #boolean(T) pred) { … } static <S,T> Set<S> map( Set<T> s, #S(T) func) { … }}
interface Set<T> extends Collection<T> { … Set<T> filter(#boolean(T)) import static Collections.filter; <S> map(#S(T)) import static Collections.map;}
Extension Methods (3)
• Using extension methods:
int ints = new int[] { 1, 2, 3, 4, 5 };int[] transformedInts = s.filter(#(int x)(x % 2 == 0)) .map(#(int x)(x + 3));// transformedInts = { 5, 7 }
int[] transformedInts = Collections.map( Collections.filter(s, #(int x)(x % 2 == 0)), #(int x)(x + 3));
Parallel Arrays API
• ParallelArray<T> is ideal candidate for extension methods• Can utilize efficiently multi-core /
multiprocessor systems
• The class ParallelArray<T> allows parallel aggregate operations over a collection• Apply transformation to each element
• Map each element to a new element
• Select subset of the elements by predicate
• Reduce elements to a single value (e.g. sum)
JSR 203:More New I/O APIs for the
Java Platform (NIO.2)
NIO2 – Introduction
• New I/O or non-blocking I/O, usually called NIO• Collection of Java APIs that offer features for
intensive I/O operations
• It was introduced with the J2SE 1.4
• NIO was developed under the Java Community Process as JSR 51
• As of 2006, an extension to NIO, called NIO2, is being developed under JSR 203• JSR 203 is scheduled to be included in JDK 7
Cool New Things: resolve()
• resolve() – resolves a relative path
public static void resolve() { FileSystem fileSystem = FileSystems.getDefault(); Path currentDir = fileSystem.getPath(".");
Path srcDir = fileSystem.getPath("src");
Path file1 = fileSystem.getPath("./Test.java"); Path file2 = fileSystem.getPath(“../Copy.java");
System.out.println( "file2: " + currentDir.resolve(srcDir).resolve(file2));}
Cool New Things: relativize()
• relativize() – makes path relative
public static void relativize() {
FileSystem fileSystem = FileSystems.getDefault();
Path source = fileSystem.getPath("."); Path temp = fileSystem.getPath("/temp");
Path relativeSource = source.toAbsolutePath(). relativize(temp.toAbsolutePath());
System.out.println(relativeSource);}
How to Copy a File
• Up to Java 6 (w/o channels) it looks like this:
• Familiar?• Most developers write this incorrectly
try { from = new FileInputStream(fromFile); to = new FileOutputStream(toFile); byte[] buffer = new byte[4096]; int bytesRead;
while ((bytesRead = from.read(buffer)) != -1) to.write(buffer, 0, bytesRead); // write} finally { // Close the streams "to" and "from"}
How to Copy a File (2)
• java.io.File is used to represent a file• @since 1.0• Is there a way to copy metadata?
• JDK7: java.io.File -> java.nio.file.Path
• java.io.File won’t be deprecated, but should• Path is a better name (might be a dir, right?)// java.io.File -> java.nio.filePathPath p = new File("/foo/bar.txt").toPath();
FileSystem local = FileSystems.getDefault();Path from = local.getPath(FileName);Path to = local.getPath(toFileName);from.copyTo(to);
Upgrade Class-Loader Architecture
The Problem
• Bug ID: 4670071
• Submit Date: 17-APR-2002
• Release Fixed: 7 (b47)• Means: Fixed in JDK7 (build 47)
• b47 got released Q1 2009
• The bug is about a classloader deadlock• deadlocks as caused by non-interceptible loadClassInternal() calls
• How many of you know about the existence of bug 4670071?
Compressed 64-bit Object Pointers
What is an oop?
• An "oop", or "ordinary object pointer" in the JVM is a managed object pointer
• It is normally the same size as a native machine pointer
• 64 bits on an 64-bit OS
• 32 bits on an 32-bit OS
• 32-bit JVM can address less than 4GB
• 64-bit JVM can address all the available RAM
• But this costs a lot of memory lost in oops
Compressed oops
• Compressed oops allow to address up to 32 GB RAM with 32-bit pointers
• The address space is mapped using a 64-bit
base and 32-bit oop
• This allows applications to address up to four
billion objects (not bytes)
• Java heap can grow up to 32 GB
Garbage-First GC (G1)
Garbage-First GC (G1)
• G1 (garbage-first) garbage collector• Improved performance and less freeze time
• Server-style garbage collector
• Targeted for multi-processors with large memories
• Meets a soft real-time goal with high probability
• Added in Milestone1 (02.01.2009)
• Released in Java 6 update 6u14
Method to close a URLClassLoader
URLClassLoader.close()
• URLClassLoader has new method called close()
• since b48 of JDK 7• Closes any JAR files that were open by the
loader• Allows the application to delete/replace these
files and if necessary to create new loaders
• Invalidates the loader, so that no new classes can be loaded from it
/** @since 1.7 */ urlClassLoader.close();
Unicode 5.1
Unicode 5.1 in Java 7
• Java 6 is Unicode 4.0 compliant
• Java 7 will be Unicode 5.1 compliant
• Most up-to-date version of Unicode is 5.2 (October 2009)
• What's new in Unicode 5 ?• Unicode 5.0 will include 1,369 new characters
and 9 new blocks (~alphabets)
• Unicode 5.1 will have 1,624 additional char’s making a grand total of 100,713 breaking the 100K mark for the first time
SCTP (Stream Control
Transmission Protocol)
SCTP
• Stream Control Transmission Protocol (SCTP) is a Transport Layer protocol
• serving in a similar role as TCP and UDP
• Features of SCTP include:
• Multihoming support: both endpoints of a connection can consist of more than one IP
• Chunks delivered within independent streams
• Protect against flooding attacks
• No Windows supports SCTP
JDK7: The SCTP Project
• The goal of this Project is:
• To develop an API for the Stream Control Transport Protocol (SCTP)
• And a corresponding OpenJDK prototype
• The API is implementation agnostic
• Included in build 56
• Could be hacked to work with JDK6
• Currently only Solaris is supported
SDP (Sockets Direct Protocol)
SDP
• The Sockets Direct Protocol (SDP) is a networking protocol originally defined by the InfiniBand Trade Association
• Transport agnostic protocol for Remote Direct Memory Access (RDMA)
• RDMA is a direct memory access from one computer’s memory into another’s without involving either one's operating system
• JDK7’s SDP implementation works, unfortunately, only on Solaris
Questions?
Java 7 New Features
Resources – Java Chronology
• JDK 7 – Features• http://openjdk.java.net/projects/jdk7/features/
• JDK 7 – Milestones• http://openjdk.java.net/projects/jdk7/milestones/
Resources – Dynamic Langs
• New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
• http://java.sun.com/developer/technicalArticles/DynTypeLang/
• John Rose's weblog at Sun Microsystems
• http://blogs.sun.com/jrose/
• JSR 292: Supporting Dynamically Typed Languages on the Java Platform
• http://jcp.org/en/jsr/detail?id=292
Resources – Project Jigsaw
• Project Jigsaw: Language changes for Modules
• http://openjdk.java.net/projects/jigsaw/doc/language.html
• Project Jigsaw – Mark Reinhold’s Blog
• http://blogs.sun.com/mr/entry/jigsaw
• Is the JDK Losing its Edge(s)?
• http://blogs.sun.com/alanb/entry/is_the_jdk_losing_its
Resources – JSR 308
• Type Annotations Specification (JSR 308)
• http://types.cs.washington.edu/jsr308/specification/java-annotation-design.html
• Type Annotations FAQ (JSR 308)• http://types.cs.washington.edu/jsr308/jsr308-faq.html
• The Checker Framework: Custom Pluggable Types for Java
• http://types.cs.washington.edu/checker-framework/current/checkers-manual.html
Resources – Project Coin
• Project Coin• http://wikis.sun.com/display/ProjectCoin/2009ProposalsTOC
• http://mail.openjdk.java.net/pipermail/coin-dev/2009-February/000001.html
• Strings in switch• http://mail.openjdk.java.net/pipermail/coin-dev/2009-February/000001.html
• Automatic Resource Management• http://mail.openjdk.java.net/pipermail/coin-dev/2009-February/000011.html
Resources – Project Coin (2)
• Improved Type Inference for Generic Instance Creation• http://mail.openjdk.java.net/pipermail/coin-dev/2009-February/000009.html
• Simplified Varargs Method Invocation• http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/000316.html
• Collection Literals• http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/001193.html
Resources – Project Coin (3)
• Indexing access syntax for Lists and Maps• http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/001108.html
• Language support for JSR 292• http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/001077.html
• Binary Literals• http://mail.openjdk.java.net/pipermail/coin-dev/2009-April/001627.html
• Underscores in numbers• http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/001208.html
Resources – Closures
• Project Lambda• http://openjdk.java.net/projects/lambda/
• Project Lambda: Straw-Man Proposal• http://cr.openjdk.java.net/~mr/lambda/straw-man/
• Closures for Java – Mark Reinhold’s Blog• http://blogs.sun.com/mr/entry/closures
Resources – NIO2
• Java New I/O
• http://en.wikipedia.org/wiki/New_I/O
• JSR 203: The Open Road – java.nio.file• http://today.java.net/pub/a/today/2008/07/03/jsr-203-new-file-apis.html
Resources – Compressed oops
• Compressed oops in the Hotspot JVM
• http://wikis.sun.com/display/HotSpotInternals/CompressedOops
• Wikipedia – 64-bit
• http://en.wikipedia.org/wiki/64-bit
• ILP32, LP64, and LLP64• http://wiki.wireshark.org/Development/Win64
• C Programming Language
• http://en.wikipedia.org/wiki/C_(programming_language)
Resources – Garbage Collection
• Garbage-First Garbage Collection• http://research.sun.com/jtech/pubs/04-g1-paper-ismm.pdf
• JavaOne: G1 Garbage Collector• http://tech.puredanger.com/2008/05/09/javaone-g1-garbage-collector
• Garbage Collection – Wikipedia• http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)
• Wikipedia – Hard and Soft Real-time Systems• http://en.wikipedia.org/wiki/Real-time_computing#Hard_and_soft_real-time_systems
Resources – Upgrade ClassLoader Architecture
• Draft Proposal for ClassLoader Deadlock Fix
• http://www.mail-archive.com/[email protected]/msg00863.html
• java.lang.ClassLoader.loadClassInternal(String) is Too Restrictive
• http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4670071
Resources – URL ClassLoader
• Closing a URLClassLoader• http://blogs.sun.com/michaelmcm/entry/closing_a_urlclassloader
• Class URLClassLoader – close()• http://download.java.net/jdk7/docs/api/java/net/URLClassLoader.html#close()
Resources – Unicode 5.1
• JDK 7 – Features – Unicode 5.1
• http://openjdk.java.net/projects/jdk7/features/#f497
• What's new in Unicode 5.0?• http://babelstone.blogspot.com/2005/11/whats-new-in-unicode-50.html
• What's new in Unicode 5.1?
• http://babelstone.blogspot.com/2007/06/whats-new-in-unicode-51.html
Resources – SCTP
• SCTP Project
• http://openjdk.java.net/projects/sctp/
Resources – SDP
• Understanding the Sockets Direct Protocol• http://java.sun.com/docs/books/tutorial/sdp/sockets/index.html
• Sockets Direct Protocol – Wikipedia• http://en.wikipedia.org/wiki/Sockets_Direct_Protocol
• Remote Direct Memory Access• http://en.wikipedia.org/wiki/Remote_Direct_Memory_Access
• Zero-copy• http://en.wikipedia.org/wiki/Zero-copy
Resources – Authors
• Authors of this presentation:• Svetlin Nakov
• http://www.nakov.com/blog/ • Mihail Stoynov
• http://mihail.stoynov.com/blog/