It's Java, Jim, but not as we know it

© Copyright Azul Systems 2017
@speakjava
It’s Java, Jim, But Not
As We Know It!
Simon Ritter
Deputy CTO, Azul Systems
1

Agenda
 Lambda expression details
 Lambda expression performance
 How far can we take lambdas?
2
Interesting
and useful
Interesting but
not so useful

Java Lambda Expressions

 Old style, anonymous inner classes
 New style, using a Lambda expression
4
new Thread(new Runnable() {
public void run() {
doSomeStuff();
}
}).start();
new Thread(() -> doSomeStuff()).start();

 Simplified representation of behaviour in Java
 Assign to variable, pass as parameter
 Use wherever the type is a Functional Interface
– Much simpler than adding a function type to Java
– Single abstract method
– Not necessarily single method
 default and static methods don’t count
5

Lambda Expression Syntax
 Like a method
– But not associated with a class
– Typed parameters, body, return type, exceptions
 Closure over values, not types
– Only capture effectively-final variables
6
(parameters) -> body
Lambda operator

Capturing Lambdas
7
class DataProcessor {
private int currentValue;
public void process() {
DataSet myData = myFactory.getDataSet();
dataSet.forEach(d -> d.use(currentValue++));
}
}

Capturing Lambdas
8
class DataProcessor {
private int currentValue;
public void process() {
DataSet myData = myFactory.getDataSet();
dataSet.forEach(d -> d.use(this.currentValue++));
}
}
Reference to this inserted
by compiler

Method References
 Method references let us reuse a method as a lambda
expression
FileFilter x = File f -> f.canRead();
FileFilter x = File::canRead;

Method References
 Format: target_reference::method_name
 Three kinds of method reference
– Static method
– Instance method of an arbitrary type
– Instance method of an existing object
10

Method References
11
Lambda
Method Ref
Lambda
Method Ref
Lambda
Method Ref
(args) -> ClassName.staticMethod(args)
(arg0, rest) -> arg0.instanceMethod(rest)
(args) -> expr.instanceMethod(args)
ClassName::staticMethod
ClassName::instanceMethod
expr::instanceMethod
Rules For Construction

Method References
(String s) -> Integer.parseInt(s);
(String s, int i) -> s.substring(i)
Axis a -> getLength(a)
Integer::parseInt
String::substring
this::getLength
Lambda
Method Ref
Lambda
Method Ref
Lambda
Method Ref
Examples

Lambda Expression
Performance

Lambdas & Anonymous Inner Classes
 Functionally equivalent
14
myList.forEach(w -> System.out.println(w));
myList.forEach(new Consumer<String>() {
@Override
public void accept(String w) {
System.out.println(w);
}
});
myList.forEach(System.out::println);

Anonymous Inner Classes
 As the name suggests, we are dealing with classes
– Compiler generates class with name like Foo$1
– Type pollution
 The class must be loaded at run time
 Instantiated like any other class
 Lambda expressions could be implemented this way
– Originally they were
– Forces an inner class where you didn’t ask for it
 You wanted a function
15

Lambda Implementation
 A better answer: invokedynamic and Method Handles
– Introduced in Java SE 7 to improve performance of
dynamically typed languages running on the JVM
– Separate binary representation of Lambda creation from
mechanics of evaluating the Lambda
– Defers implementation of the Lambda to runtime
 Not fixed in the binary format
 JVM can provide better implementations when ready
16

Lambda Compilation
 Lambda body converted to method
 Non-capturing Lambda
– Simple conversion to static method in the class where the
lambda is used
 Capturing Lambdas
– Static method with captured variables prepended as
parameters
 Instance capturing Lambdas
– Synthetic instance method of class using Lambda
17

Lambda Compilation
 Generate invokedynamic call (Lambda factory)
– Call site returns instance of (lambda) functional interface
 Bootstrap method for Lambda factory (meta-factory)
– java.lang.invoke.LambdaMetaFactory
– Call sites are lazily evaluated
 Factory sites that are never invoked are never linked
 Unused lambdas have no overhead
18

Implementation Differences
 Lambdas
– Linkage (CallSite)
– Capture
– Invocation
19
 Anonymous inner classes
– Class loading
– Instantiation
– Invocation
 Non-capturing lambdas automatically optimise
 Method references are slightly more optimal
 -XX:+TieredCompilation gives better Lambda results
– Advice is don’t use -XX:-TieredCompilation

How Far Can We Take
Lambdas?
With inspiration from Jarek Ratajski

© Copyright Azul Systems 2017 21
Alonso Church
The λ Calculus (1936)
What does this have to do with Java?

Exploding Head Lambdas
 Java programmers are typically imperative programmers
 Functional programming is not imperative
– As we’ll see
 Lambda Calculus and Turing Machines are equivalent
 But will give you a headache
– At least it did me!
 What can we do only using Lambda expressions?
– And one functional interface
22

Functional Interface
@FunctionalInterface
public interface Lambda {
Lambda apply(Lambda lambda);
}

Function Basics
 Identity [ λx.x ]
Lambda identity = (x -> x);
Lambda identity = new Lambda() {
Lambda apply(Lambda x) {
return x;
}
};

Function Basics (Booleans)
 Boolean false [ λf.λx.x ]
boolFalse = f -> (x -> x); // Always returns identity
boolFalse = new Lambda() {
Lambda apply(Lambda f) {
return new Lambda {
Lambda apply(Lambda x) {
return x;
}
}}};

Function Basics (Booleans)
 Boolean true [ λf.λx.f ]
boolTrue = f -> (x -> f); // Never returns identity

Church Numerals
 Zero [ λf.λx.x ]
• Identity for addition and subtraction (a ± 0 = a)
• The Lambda is the same as false
• The function, f, is applied zero times to the argument
zero = f -> (x -> x);
 One [ λf.λx.(f x) ]
one = f -> (x -> f.apply(x));
 Two [ λf.λx.(f (f x)) ]
two = f -> (x -> f.apply(f.apply(x)));
27

Church Encoding
 Successor: n++ [ λn.λf.λx.f(n f x) ]
successor =
n -> f -> x -> f.apply(n.apply(f).apply(x));
28

Church Encoding
 Predecessor: n--
29
predecessor = n -> f -> x ->
n.apply(g -> h -> h.apply(g.apply(f)))
.apply(u -> x).apply(u -> u);
[ λn.λf.λx.n(λg.λh.h(g f))(λu.x)(λu.u) ]

Church Encoding
 Add: m + n [ λm.λn.λf.λx ((m f) ((n f) x)) ]
m -> n -> f -> x -> m.apply(f).apply(n.apply(f).apply(x))
 Subtract: m - n [ λm.λn.(n predecessor) m ]
m -> n -> m.apply(predecessor).apply(n)
30

Solving 2 + 2 With Lambdas
Lambda two = f -> x -> f.apply(f.apply(x));
Lambda plus = m -> n ->
f -> x -> m.apply(f).apply(n.apply(f).apply(x));
Lambda four = plus.apply(two).apply(two);
4 = + 2 2 (Polish notation)

n -> f -> x -> f -> x -> f.apply(f.apply(x)).apply(f)
.apply(n.apply(f).apply(x))

n -> f -> x -> f -> x -> f.apply(f.apply(x)).apply(f)
.apply(n.apply(f).apply(x))
f -> x -> f -> x -> f.apply(f.apply(x)).apply(f)
.apply(f -> x -> f.apply(f.apply(x).apply(f).apply(x))

f -> x ->
f -> x -> f.apply(f.apply(x)).apply(f)
.apply(f -> x -> f.apply(f.apply(x)).apply(f).apply(x))
f -> x ->
x -> f.apply(f.apply(x))

f -> x ->
f -> x -> f.apply(f.apply(x)).apply(f)
f -> x ->
f -> x ->
.apply(x -> f.apply(f.apply(x)).apply(x))

f -> x -> x -> f.apply(f.apply(x))
.apply(x -> f.apply(f.apply(x)).apply(x))
.apply(f.apply(f.apply(x)))
.apply(f.apply(f.apply(x)))
f -> x -> f.apply(f.apply(f.apply(f.apply(x))) = 4!

Summary

Lambda Expressions
 Very useful and powerful
– Succinct way to parameterise behaviour
 Better performance than anonymous inner class
– Invokedynamic implementation
 Can be used in weird and wonderful ways
– Not necessarily to be recommended!
38

More Information
 Dixin Yan’s blog
– weblogs.asp.net/dixin (C# based, but useful)
– October 2016
 Jarek’s presentation from Voxxed Zurich
– https://www.youtube.com/watch?v=Dun8ewSeX6c
39

@speakjava
It’s Java, Jim, But Not
As We Know It!
Simon Ritter
Deputy CTO, Azul Systems
40

It's Java, Jim, but not as we know it

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to It's Java, Jim, but not as we know it

Similar to It's Java, Jim, but not as we know it (20)

More from Simon Ritter

More from Simon Ritter (20)

Recently uploaded

Recently uploaded (20)

It's Java, Jim, but not as we know it

Editor's Notes