Java functional interface with no arguments

Java 8 functional interface with no arguments and no return value

Question: Is there any way to do asynchronous IO in Java without blocking any threads (including background threads)? Threads of thread pool are only used to dispatch results and do not block, unless the end user programmer blocks that thread.

Java 8 functional interface with no arguments and no return value

What is the Java 8 functional interface for a method that takes nothing and returns nothing?

I.e., the equivalent to to the C# parameterless Action with void return type?

If I understand correctly you want a functional interface with a method void m() . In which case you can simply use a Runnable .

@FunctionalInterface public interface Procedure < void run(); default Procedure andThen(Procedure after)< return () ->< this.run(); after.run(); >; > default Procedure compose(Procedure before) < return () ->< before.run(); this.run(); >; > > 

public static void main(String[] args) < Procedure procedure1 = () ->System.out.print("Hello"); Procedure procedure2 = () -> System.out.print("World"); procedure1.andThen(procedure2).run(); System.out.println(); procedure1.compose(procedure2).run(); > 

@FunctionalInterface allows only method abstract method Hence you can instantiate that interface with lambda expression as below and you can access the interface members

 @FunctionalInterface interface Hai < void m2(); static void m1() < System.out.println("i m1 method. "); >default void log(String str) < System.out.println("i am log method. " + str); >> public class Hello < public static void main(String[] args) < Hai hai = () -><>; hai.log("lets do it."); Hai.m1(); > > 

i am log method. lets do it. i m1 method. 

Miguel Gamboa

Miguel Gamboa

Radios Parlante «Miguel Gamboa»

Instalación de una Radio Parlante » Miguel Gamboa » Comunidad Colinas de San Lorenzo, Triunfadores Próximos Licenciados en Comunicación Social …

Non-blocking Async IO in Java

Is there any way to do asynchronous IO in Java without blocking any threads (including background threads)? Coming from C#, my understanding of async IO is that it when you call

The calling thread (part of a threadpool) steps into the ReadAsync function, at some point calls an asynchronous read function from the OS kernel, and then adds itself back to the threadpool to pick up other Tasks . Once the read is completed, the threadpool is notified and another thread picks up the rest of the Task .

In Java, on the other hand, the documentation and this answer seem to suggest that asynchronous IO functions are simply called by a background thread that then blocks. This seems less performant. Is there any way to achieve true, non-blocking IO in Java?

The AsynchronousFileChannel.open() returns instances of different implementations according to the running environment. On Windows it should return an instance of WindowsAsynchronousFileChannelImpl which uses I/O completion port and avoids blocking threads on IO operations. Threads of thread pool are only used to dispatch results and do not block, unless the end user programmer blocks that thread.

The RxIo is built on top of AFC and provides the AsyncFiles equivalent to the synchronous Files class but with an asynchronous API. Taking advantage of the continuation-passing style of CompletableFuture (equivalent to .net Task ) you may read a file content without blocking:

AsyncFiles .readAll(path) .thenAccept(body -> /* invoked on completion */) .exceptionally(excep -> /* invoked on error*/ 

You may run the unit tests of RxIo and place a breakpoint at open() and inspect the implementation of WindowsAsynchronousFileChannelImpl .

Until some time ago there were problems with asynchronous file I/O on Linux. There was an aio interface, but it was only asynchronous for O_DIRECT, which is quite inconvenient for standard use cases. So the standard JDK implementation of AsynchronousFileChannel for Linux internally uses thread pooling and simple blocking I/O which is not really asynchronous I/O.

Things have changed a bit since Linux introduced the io_uring interface. It is now possible to use real non-blocking file I/O not just for O_DIRECT but for buffered I/O too. And a lot more, to reduce overhead of syscall and increase performance. Read more about io_uring.

At the moment there is no built-in support for io_uring in Java. There have been rumors that support may appear for better project Loom support, but that’s just a rumors.

There are third party libraries that add asynchronous file I/O support via io_uring for Java — jasyncfio.

Lazy field initialization with lambdas

I would like to implement lazy field initialization (or deferred initialization) without an if statement and taking advantage of lambdas. So, I would like to have the same behavior of the following Foo property but without the if :

Ignore the fact that this solution is not guaranteeing safe use for: 1) multi-threading; 2) null as a valid value of T .

So, to express the intention that the initialization of the fooField is deferred until its first use I would like to declare the fooField of the type Supplier such as:

class A < private SupplierfooField = () -> expensiveInit(); public T getFoo() < return fooField.get(); >> 

and then in the getFoo property I would just return fooField.get() . But now I want that next invocations to getFoo property avoid the expensiveInit() and just return the previous T instance.

How can I achieve that without using an if ?

Despite naming conventions and replacing the -> by => , then this example could be also considered in C#. However, NET Framework version 4 already provides a Lazy with the desired semantics.

Within your actual lambda, you can simply update the fooField with a new lambda, such as:

class A < private SupplierfooField = () -> < T val = expensiveInit(); fooField = () ->val; return val; >; public T getFoo() < return fooField.get(); >> 

Again this solution is not thread-safe as is the .Net Lazy , and does not ensure that concurrent calls to the getFoo property return the same result.

The approach taken by Miguel Gamboa’s answer is a fine one:

private Supplier fooField = () -> < T val = expensiveInit(); fooField = () ->val; return val; >; 

It works well for one-off lazy fields. However, if more than one field needs to be initialized this way, the boilerplate would have to be copied and modified. Another field would have to be initialized like this:

private Supplier barField = () -> < T val = expensiveInitBar(); // val; // ; 

If you can stand one extra method call per access after the initialization, I'd do it as follows. First, I'd write a higher-order function that returns an instance of Supplier that contains the cached value:

static Supplier lazily(Supplier supplier) < return new Supplier() < Z value; // = null @Override public Z get() < if (value == null) value = supplier.get(); return value; >>; > 

An anonymous class is called for here because it has mutable state, which is the cached of the initialized value.

Then, it becomes quite easy to create many lazily initialized fields:

Supplier fieldBaz = lazily(() -> expensiveInitBaz()); Supplier fieldGoo = lazily(() -> expensiveInitGoo()); Supplier fieldEep = lazily(() -> expensiveInitEep()); 

Note: I see in the question that it stipulates "without using an if ". It wasn't clear to me whether the concern here is over avoiding the runtime expensive of an if-conditional (really, it's pretty cheap) or whether it's more about avoiding having to repeat the if-conditional in every getter. I assumed it was the latter, and my proposal addresses that concern. If you're concerned about runtime overhead of an if-conditional, then you should also take the overhead of invoking a lambda expression into account.

Taking Miguel Gamboa’s solution and trying to minimize the per-field code without sacrificing its elegance, I came to the following solution:

interface Lazy extends Supplier  < Supplierinit(); public default T get() < return init().get(); >> static Supplier lazily(Lazy lazy) < return lazy; >static Supplier value(T value) < return ()->value; > Supplier fieldBaz = lazily(() -> fieldBaz=value(expensiveInitBaz())); Supplier fieldGoo = lazily(() -> fieldGoo=value(expensiveInitGoo())); Supplier fieldEep = lazily(() -> fieldEep=value(expensiveInitEep())); 

The per-field code only slightly bigger than in Stuart Marks’s solution but it retains the nice property of the original solution that after the first query, there will be only a lightweight Supplier which unconditionally returns the already computed value.

Project Lombok provides a @Getter(lazy = true) annotation which does exactly what you need.

Java 8 functional interface with no arguments and no, Miguel Gamboa. asked May 26, 2014 at 11:08. Miguel Gamboa Miguel Gamboa. 8,312 6 6 gold badges 45 45 silver badges 87 87 bronze …

Источник

Java 8 Functional Interface with No Arguments and No Return Value

Java 8 introduced the concept of functional interfaces which allows the use of lambda expressions to instantiate interfaces. A functional interface is an interface that has only one abstract method.

In this guide, we will be discussing Java 8 functional interfaces with no arguments and no return value.

Syntax

The syntax for creating a functional interface with no arguments and no return value is as follows:

@FunctionalInterface public interface MyFunctionalInterface

The `@FunctionalInterface` annotation is optional but it is recommended to use it to ensure that the interface has only one abstract method.

Example

Let’s take an example where we want to print a message using a lambda expression. We can create a functional interface that has a method to print the message.

@FunctionalInterface interface MessagePrinter < void printMessage(); >public class LambdaExample < public static void main(String[] args) < MessagePrinter messagePrinter = () ->System.out.println("Hello, World!"); messagePrinter.printMessage(); > > 

In the example above, we have created a functional interface `MessagePrinter` with a single method `printMessage()`. We have used a lambda expression to implement the method and print the message “Hello, World!”.

Conclusion

In conclusion, Java 8 functional interfaces with no arguments and no return value provide a concise and efficient way to implement interfaces using lambda expressions. By using functional interfaces, we can reduce the amount of boilerplate code required and make our code more readable and maintainable.

Источник

Java 8 functional interface with no arguments and no return value

What is the Java 8 functional interface for a method that takes nothing and returns nothing?

I.e., the equivalent to to the C# parameterless Action with void return type?

Java Solutions

Solution 1 - Java

If I understand correctly you want a functional interface with a method void m() . In which case you can simply use a Runnable .

Solution 2 - Java

@FunctionalInterface public interface Procedure < void run(); default Procedure andThen(Procedure after) < return () ->< this.run(); after.run(); >; > default Procedure compose(Procedure before) < return () ->< before.run(); this.run(); >; > > 

public static void main(String[] args)< Procedure procedure1 = () -> System.out.print("Hello"); Procedure procedure2 = () -> System.out.print("World"); procedure1.andThen(procedure2).run(); System.out.println(); procedure1.compose(procedure2).run(); > 

Solution 3 - Java

@FunctionalInterface allows only method abstract method Hence you can instantiate that interface with lambda expression as below and you can access the interface members

 @FunctionalInterface interface Hai < void m2(); static void m1( ) < System.out.println("i m1 method. "); > default void log(String str) < System.out.println("i am log method. " + str); > > public class Hello < public static void main(String[] args) < Hai hai = () -> <>; hai.log("lets do it."); Hai.m1(); > > 

i am log method. lets do it. i m1 method. 

Источник