Jug java7

Java 7 new features Java User Group Latvia www.jug.lv

Java 7
Project began in August 2006
JDK7 is done via Open JDK effort
Major release – JVM, language and library changes
Current status – milestone M10, build b115, planned release Mid 2011

Initially planned features
Closures – Project Lambda
Small language changes – Project Coin
Modularity for Java platform – Project Jigsaw
Support for dynamically-typed languages
Core and IO library extensions
Swing and UI related changes
Support for updated standards - Unicode, localization, security, cryptography, XML and JDBC

Two release plans
Plan A
All features, release in Mid 2012
Plan B
JDK 7 minus Lambda, Jigsaw and part of Coin, release in Mid 2011
JDK 8, release in late 2012

Plan B selected
Plan A
All features, release in Mid 2012
Plan B
JDK 7 minus Lambda, Jigsaw and part of Coin, release in Mid 2011
JDK 8, release in late 2012

Approved feature list
JSR 292: Support for Dynamically-Typed Languages (“InvokeDynamic”)
Small Language Enhancements (Project Coin)
Concurrency and Collections Updates (including the Fork/Join Framework)
Upgrade Class-Loader Architecture
Unicode 6.0
JSR 203: More New I/O APIs (“NIO 2”)
Updated cryptography
JDBC 4.1
Translucent & Shaped Windows
Heavyweight/Lightweight Component Mixing
Swing: Nimbus Look-and-Feel, JLayer Component
Update the XML Stack (JAXP, JAXB, & JAX-WS)

Language enhancements - Project Coin

Strings in switch statement
GregorianCalendar c = new GregorianCalendar();
int monthNameToDays(String s, int year) {
switch (s) {
case "April": case "June":
case "September": case "November":
return 30;
case "January": case "March":
case "May": case "July":
case "August": case "December":
return 31;
case "February":
return 28 + (c.isLeapYear(year) ? 1 : 0);
default :
return -1;
}
}

Improved Type Inference for Generic Instance Creation
Map <Integer, List<String>> map =
new HashMap <Integer, List<String>> ();
New “diamond” operator :
Map<Integer, List<String>> map = new HashMap<>();
List<?> l = new ArrayList<>();

Try-with-resources
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 {
out.close();
}
} finally {
in.close();
}
}

Try-with-resources
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;
}
}

Try-with-resources
void copy(String src, String dest) {
try (InputStream in = new FileInputStream(src);
OutputStream out = new FileOutputStream(dest)) {
byte[] buf = new byte[8192];
int n;
} catch (IOException e) {
e.printStackTrace();
}
}

Try-with-resources
package java.lang;
public interface AutoCloseable {
void close() throws Exception;
}
package java.io;
public interface Closeable extends AutoCloseable {
void close() throws IOException;
}

Multi-catch
try {
String. class .newInstance();
} catch ( final IllegalAccessException | InstantiationException e) {
e.printStackTrace();
throw e;
} catch (Exception e) {
// handle exception
}

Integer and binary literals
byte b = 0b00100101;
int phoneNumber = 123_456_7890;
long creditCardNumber = 1234_5678_9012_3456L;
int hexBytes = 0xFF_EC_DE_5E;

Simplified Varargs Method Invocation
List<String> a = new ArrayList<String>(),
b = new ArrayList<String>(),
c = new ArrayList<String>();
// Warning: [unchecked] unchecked generic array
// creation for varargs parameter of type
// List<String>[]
return Arrays.asList(a, b, c);

Language enhancements postponed until Java 8

Language enhancements in Java 8
Collection literals and indexing
List<String> cities = ["Riga", "London", "Tokio"];
Set<String> countries = { "LV", "LT", "EE" };
Map<String, Double> atomicWeights = { "H" : 1.0079,
"He" : 4.0026, "Li" : 6.941 };
String city = cities[0];
Double weight = atomicWeights["H"];

Closures
#{ int x -> x + 1 }
#{ System.out.println("Hello, World!") }
list.forEach(#{ e -> System.out.println(e) });
Arrays.sort(array, #{ a, b -> a.compareToIgnoreCase(b) });

Method references
class Person {
public static int compareByAge(Person a, Person b) { ... }
}
Person[] people = ...
Arrays.sort(people, #Person.compareByAge);
Arrays.sort(people, #Person.compareByAge(Person, Person));
Arrays.sort(people, #comparatorHolder.comparePersonByAge);

JSR 292 – Support for Dynamically-Typed languages

JSR 292 - Overview
Dynamic languages on the JVM
JSR 223 implemented in JDK6
JVM initially designed for statically-typed language
4 bytecode instructions available for method invocations
Invokestatic
Invokevirtual
Invokespecial
Invokeinterface
new bytecode instruction "invokedynamic“ and Method Handles
java.dyn package

JSR 292 – Method Handles
Method handle is a lightweight pointer or reference to a method
java.dyn.MethodHandle
Example
public void testMethodHandle() throws Throwable {
MethodHandle hndl = MethodHandles.lookup().findVirtual(
PrintStream. class , "println",
MethodType.methodType( void.class , String. class ));
hndl.< void >invokeGeneric(System.out, "Hello, MethodHandle!");
}

JSR 292 Invokedynamic – how it works?
JVM encounters invokedynamic instruction
JVM invokes the bootstrap method
The Bootstrap method resolves the method handle
The Bootstrap method must be previously registered in JVM
Future calls don't require the Bootstrap method invocation

JSR 292 InvokeDynamic, Java example
public void testDynamic() throws Throwable {
InvokeDynamic.< void >greet("World");
}
static {
Linkage.registerBootstrapMethod("bootstrap");
}
public static void greet(String str) {
System.out.println("Hello, dynamic " + str);
}
private static CallSite bootstrap(Class caller, String name, MethodType type) {
CallSite site = new CallSite(caller, name, MethodType.make( void.class ));
site.setTarget(MethodHandles.lookup().findStatic(Test. class , name, MethodType.make( void.class , String. class )));
return site;
}

NIO.2 – Paths
java.nio.file.Path – a replacement for java.io.File
File file = new File("index.html");
Path path = Paths.get("index.html");
Path path = new File("index.html").toPath();
All Path methods throw exceptions in case of errors
if (!file.delete()){ ... } try { path.delete(); } catch (IOException e) { ... }

NIO.2 – FileSystem
Provides interface to file system
Default file system is local/platform file system
FileSystem local = FileSystems.getDefault();
Path p = local.getPath(“filename");
Path p2 = Paths.get(“filename”);
Jar and Zip file systems included

NIO.2 – DirectoryStream
DirectoryStream to iterate over the entries
Scales to large directories
Filter using glob, regex, or custom filter
try (DirectoryStream<Path> stream =
dir.newDirectoryStream("*.{c,h,cpp,hpp,java}")) {
for (Path entry : stream) {
...
}
}

NIO.2 - Files.walkFileTree
Walks a file tree rooted at a given starting file
Invoke FileVisitor method for each file/directory
interface FileVisitor<T> {
FileVisitResult preVisitDirectory(T dir);
FileVisitResult visitFile(T file, BasicFileAttributes attrs);
FileVisitResult visitFileFailed(T file, IOException exc);
FileVisitResult postVisitDirectory(T dir, IOException exc);
}
SimpleFileVisitor – a default implementation

NIO.2 - File change notifications
Current approach – polling the file system
WatchService – watch registered objects (Watchables) for changes
WatchService watcher = path.getFileSystem().newWatchService();
path.register(watcher, ENTRY_CREATE, ENTRY_MODIFY);
for (;;) {
WatchKey watchKey = watcher.take();
for (WatchEvent event : watchKey.pollEvents()) {
System.out.println(event.kind() + " : “
+ event.context());
}
watchKey.reset();
}

Fork/Join framework

Fork/Join Framework
Multicore era approaching
Moore’s Law doesn’t work since ~2003
Current solution (java.util.concurrent) has its limitations
Coarse grained parallelism
Inefficient CPU utilization
Solution: Fork/Join framework

Fork/Join – Divide and conquer
Result solve(Problem problem) {
if (problem.size < SEQUENTIAL_THRESHOLD)
return solveSequentially(problem);
else {
Result left, right;
INVOKE-IN-PARALLEL {
left = solve(extractLeftHalf(problem));
right = solve(extractRightHalf(problem));
}
return combine(left, right);
}
}

Fork/Join - architecture
ForkJoinExecutor, ForkJoinTask
Each worker thread has it’s own task queue (deque) – no concurrency between treads for tasks
Work stealing algorithm – threads are never idle

Fork/Join - ParallelArray
ParallelArray<T>, ParallelLongArray etc.
Supports filtering, mapping, searching, sorting, reducing etc.

ParallelArray example
ParallelArray<Order> orders = new ParallelArray<>(fjPool, data);
double maxAmount = orders
. withFilter (madeThisYear)
. withMapping (getAmount)
. max ();
static final Ops.Predicate<Order> madeThisYear = new Ops.Predicate<>() {
public boolean op(Order o) {
return o.getYear() == thisYear;
}
};
static final Ops.ObjectToDouble<Order> getAmount = new Ops.ObjectToDouble<>() {
public double op(Order o) {
return o.getAmount();
}
};

Try it yourself
Download JDK 7 early access https://jdk7.dev.java.net/

Questions

http://jujo00obo2o234ungd3t8qjfcjrs3o6k-a-sites-opensocial.googleusercontent.com	28
http://www.jug.lv	3
http://jugpreview.tumblr.com	1

Jug java7

by Dmitry Buzdin

Accessibility

Categories

Upload Details

Usage Rights

3 Embeds 32

Statistics

Jug java7 Presentation Transcript