Java 7 Key Features

What‟s New()
What‟s Next()

©Copyright 2011

Disclaimer
I am just an ordinary developer
I don‟t work for Oracle

Mattias Karlsson

Avega Group

Twitter: @matkar
www.Linkedin/in/mattiask

Javaforum
Javaforum

www.jforum.se

History
JDK/YEAR Comment
Feb 1997 Retooling of the AWT event model, inner
JDK 1.1 classes added, JavaBeans and JDBC.

Dec 1998 Reflection, a Collections framework, Java
J2SE 1.2 (Playground) Swing API Java Plug-in, JIT compiler.

May 2000 HotSpot JVM, JavaSound, JNDI and JPDA
J2SE 1.3 (Kestrel)
Feb 2002 RegEx, exception chaining, XML parser and
Java SE 1.4 (Merlin) XSLT (JAXP), Java Web Start

Sep 2004 for-each loop, generics, autoboxing and var-
Java SE 5 (Tiger) args

Dec 2006 scripting languages with the JVM, VB lang
Java SE 6 (Mustang) support. Annotations (JSR 269)

Java SE 7

Started in Aug 2006

Why was 7 delayed
• Open Sourcing JDK
• Conflicts Blocking JCP
• Sun Finance
• JavaFX
• Oracle Deal

Trouble in paradise
• James Gosling leaving Oracle
• Oracle vs Google
• Apache leaving JCP
• Doug Lea, Bob Lee leaving JCP

Java 7
Plan A,
JDK 7
Late 2012

”It„s been clear for some time that the
most recent JDK 7 development
schedule is, to put it mildly, Unrealistic”

(Mark Reinhold, 8 Sep 2010)

Plan B (Mark R)
8 Sep 2010 ”Re-thinking JDK 7”
20 Sep 2010 ”It‟s time for…Plan B”
10 Oct 2010 ”Plan B: The details”

Plan B
JDK 8
7

Late 2012

Mid 2011 Late 2012

Plan B

New garbage collector G1

Library changes

Enhancements to the JVM

JDK 7 Language changes (Coin)

Concurrency and collections
JSR 336 NIO.2

G1 Garbage collector
• Still considered experimental

• Leads to much smaller pause times

• Parallelism and Concurrency

• Generational

• Compaction

• Predictability (over CMS)

Using G1
• Replace CMS (Concurrent mark sweep) GC

• Enable with:
-XX:+UnlockExperimentalVMOptions –XX:+UseG1GC

• GC Paus time goal:
-XX:MaxGCPauseMillis=50

www.oracle.com/technetwork/java/javase/tech/g1-intro-jsp-135488.html

Benchmarks
• Test 1. Add 5 Million String values (each calculated with
some complex Math arithmetic)

• Test 2. ArrayList <String> with 5 Million insertions (with
values from Test1)

• Test 3. HashMap <String, Integer> with 5 million keys,
values. Each key, value pair is being calculated via
concurrent thread)

• Test 4. Printing 5 million items of ArrayList

http://geeknizer.com/java-7-whats-new-performance-benchmark-1-5-1-6-1-7/

Performance


Performance

Java 6 18% faster then Java 5
Java 7 46% faster then Java 6

Concurrency Matters Again
10,000000
1,000,000 Transistors

100,000
10,000
1,000 Clock (MHz)
100
10
1
1970 1980 1990 2000 2010

Fork/Join
Java 7 concurrency
JSR 166y

JSR 166y Fork/Join
• similar to MapReduce
• useful for a certain class of problems

JSR 166y Fork/Join
Result solve(Problem problem) {

if (problem is small enough)
directly solve problem
else {
split problem into independent parts
fork new subtasks to solve each part
join all subtasks
compose result from subresults
}
}

JSR 166y Fork/Join
• Create one ForkJoinPool
• Wrap code in ForkJoinTask
• Subclass RecursiveAction or RecursiveTask<E>
• Need to override compute() method

download.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html

class Sum extends RecursiveTask<Long> {
static final int SEQUENTIAL_THRESHOLD = 1000;
Sum(int[] arr, int lo, int hi) {
array = arr; low = lo; high = hi;
}
protected Long compute() {
if(high - low <= SEQUENTIAL_THRESHOLD) {
long sum = 0;
for(int i=low; i < high; ++i)
sum += array[i];
return sum;
} else {
int mid = low + (high - low) / 2;
Sum left = new Sum(array, low, mid);
Sum right = new Sum(array, mid, high);
invokeAll(left, right);
return right.join() + left.join();
}
}
}

DEMO
Fork/Join Java 7
JSR 166y

Still too complicated?
mutable state, locks and visible by default is outdated
java.util.concurrent helps, but can only go so far

move from explicit to implicit parallelism

Other JVM Languages
(free to innovate)

Scala/Akka
• Powerful actors model
• Parallel Collections

Clojure
• Immutable by default
• Thread-isolation by default
• STM subsystem
• Multiple concurrency models

Project Coin
A set of small language changes
should be added to JDK 7
(OpenJDK)

Strings in switch

Add the ability to switch on string values
analogous to the existing ability to switch
on values of the primitive types.

Strings in switch
String s = ...
switch(s) {
case "quux":
processQuux(s);
// fall-through
case "bar":
processFooOrBar(s);
break;
case "baz":
processBaz(s);
default:
processDefault(s);
break;
}

Improved Exception
Handling

• Catching multiple exception types
• A single catch clause can now catch
more than one exception types
• Improved checking for re-thrown
exceptions

Improved Exception
Handling
try {
doWork(file);
} catch (IOException|SQLException ex) {
throw ex;*
}

try {
doWork(file);
} catch (final Throwable t) {
throw t; // ExceptionA or ExceptionB
}

Underscore in numbers

public static void main(String... args) {
// THE OLD WAY
int oldBillion = 1000000000;

// THE NEW WAY
int newBillion = 1_000_000_000;
}

Automatic Resource Management
• A *resource* is as an object that used to be closed
manually

• java.io.InputStream
• OutputStream
• Reader, Writer
• java.sql.Connection, Statement, ResultSet
• When the statement completes, whether normally or
abruptly, all of its resources are closed automatically.

Pre Java 7
public void copy(String src, String dest) throws IOEx{
InputStream in = new FileInputStream(src);
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 {
in.close();
out.close();
}
}

Pre Java 7
InputStream in = new FileInputStream(src);
try {
OutputStream out = new FileOutputStream(dest);
try {
int n;
} finally {
out.close();
}
} finally {
in.close();
}
}

Automatic Resource Management
try ( InputStream in = new FileInputStream(src);
OutputStream out = new FileOutputStream(dest)){
int n;
}
//in and out closes automagically
}

Improved Type Inference for
Generic Instance

Improved Type Inference for
Generic Instance

Map<String, List<String>> anagrams =
new HashMap<String, List<String>>();

Map<String, List<String>> anagrams =
new HashMap<>();

NIO.2
Network and File System
JSR 203

NIO.2
Network and File System – JSR 203

• java.io.File
• java.nio.file.Path
• java.nio.file.FileSystem
• Other Usefull Methods

Pre Java 7
URL url = new URL("http://www.blog.se/?page_id=1");
try (
FileOutputStream fos =
new FileOutputStream(new File("output.txt"));
InputStream is = url.openStream() ){
byte[] buf = new byte[4096];
int len;
while ((len = is.read(buf)) > 0){
fos.write(buf, 0, len);
}
} catch (IOException e){
e.printStackTrace();
}

NIO.2
Network and File System – JSR 203
URL url = new URL("http://www.blog.se/?page_id=1");
try (InputStream in = url.openStream()) {
Files.copy(in, Paths.get("output.txt"));
}
catch(IOException ex){
ex.printStackTrace();
}

Da Vinci Machine Project

• Support for dynamically typed languages
• Python, Ruby, Perl, Javascript, Groovy...

• Implementations will be more efficient
• JVM level support
• for such languages and their implementers

Charles Nutter
co-leads Jruby project
Engine Yard

JSR-292

invokedynamic
Method Handles
WTF?

Without invokedynamic
Four existing forms of method dispatch
virtual, interface, special, super

JVM decides how they work
What if you don‟t fit?

invokedynamic
User-defined dispatch
Name, signature as usual
Additional bootstrap method handle
Bootstrap called first time to wire it up
JVM then optimizes like “real Java”

Method Handles
Super-awesome function pointers
Faster than reflection
Curry-able
Still talking directly to JVM
Used by invokedynamic bootstrapping

invokedynamic

bootstrap
1st time method
invokedynamic
bytecode JVM

target
2nd time
method

Example

public static void print(String s) {
System.out.println(s);
}

Example

public static void main(java.lang.String[]);
Code:
0: ldc #9 // String Hello, invokedynamic!
2: invokedynamic #18, 0 // InvokeDynamic #0:print:(Ljava/lang/String;)V
7: return

invokedynamic bootstrap name and
bytecode handle signature

Example

public static CallSite bootstrap(Lookup lookup,
String name,
MethodType signature{
MethodHandle handle = lookup.findStatic(this_class, name, signature);
CallSite site = new ConstantCallSite(handle);
return site;
}

JVM languages to benefit from
invokedynamic

• These gains will vary:
• JRuby ?

• Clojure ?

• Increasing its performance

• Big potential wins

Other stuff in
• TLS 1.2
• Elliptic-curve cryptography (ECC)
• JDBC 4.1
• Binary literals
• Better way to handle unsigned literals
• Unicode 6.0
• Locale enhancement
• Support for IETF BCP 47 and UTR 35

Other stuff in

• New platform APIs for 6u10 graphics features
• Swing Nimbus look-and-feel
• Swing JLayer component
• Updated XML stack

Java 7 Runtimes
• Windows x86
• Server 2008, Server 2008 R2, 7 & 8
• Windows Vista, XP
• Linux x86
• Oracle Linux 5.5+, 6.x
• Red Hat Enterprise Linux 5.5+, 6.x
• SuSE Linux Enterprise Server 10.x, 11.x
• Ubuntu Linux 10.04 LTS, 11.04
• Solaris x86/SPARC
• Solaris 10.9+, 11.x

Other runtimes
”The IBM SDK for Java V7 is now available for
the following platforms:” - 20 Sep 2011

• AIX
• Linux
• z/OS

http://openjdk.java.net/projects/macosx-port/

Java 7 Tool Support
NetBeans 7
Eclipse 3.7 3.8 4.1 4.2
IntelliJ 10.5

JVM Convergence
Project “HotRockit”

HotSpot HotRockit JRockit

Plan B
Modularization (Jigsaw)
Language and VM Support
Platform Modularization
Project Lambda (JSR 335)
Lambda Expressions for Java
Type Annotations (JSR 308)
JDK 8
Project Coin part II
Date and Time API (JSR 310)
JSR 337

Plan B++
Project Nashorn
New implementation of JavaScript
Built from the ground up
Leverage JVM and invoke dynamic
Java FX 3.0
Open Sourced
Bundled with Java 8 JDK 8

JSR 337

Schedule

May 2011: Expert Group formation
Sep 2011: Early Draft Review
Feb 2012: Public Review
May 2012: Proposed Final Draft
Oct 2012: Final Release JDK 8

JSR 337

Schedule

May 2011: Expert Group formation
Sep 2011: Early Draft Review
Feb 2012: Public Review
May 2012: Proposed Final Draft
Summer 2013: Final Release JDK 8

JSR 337

Schedule

JDK 8, b10
Developer Preview
Now Available!
JDK 8

JSR 337
jdk8.java.net

JCP.next
• Using the process to improve the process
• JSR 348
• Transparency
• Participation
• Agility
• Governance
• A second JSR will be filed soon
• JavaSE and JavaME EC - merged

JCP, new
members
Twitter
Azul System

We‟re moving again
• The JCP Dead Lock Needed to be Broken
• OpenJDK is liberated (GPL)
• JUG attendances are growing
• Oracle marketing estimates 9-10 million devs
• Dozens of new JVM languages
• A Vibrant Java Ecosystem

Summary
• Java 7 is GA
• Java 8 is on its way
• The JVM Rocks
• JCP.next
• The community is very much alive!

Mattias Karlsson
www.linkedin.com/in/mattiask
twitter: @matkar
mattias.karlsson@avegagroup.s
e

Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names
appearing on the slides may be trademarks of their respective owners.

The development, release, and timing of any features or functionality described for Oracle„s
products remains at the sole discretion of Oracle and JCP

©Copyright 2011

Java 7 Key Features

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

Similaire à Java 7 Key Features

Similaire à Java 7 Key Features (20)

Dernier

Dernier (20)

Java 7 Key Features