Category Archives: Java

Effective Java – Item 7 – Elimine referências obsoletas a objetos

Gerenciamento de memória em linguagens com Java, que possuem mecanismo de coleta de lixo, ou garbage collection mechanism, podem evitar problemas de perda de memória, ou “memory leaks“.

As “Memory Leaks” ocorrem quando objetos que já não são utilizados ainda ocupam espaço na memória. Esses objetos estão no Heap e suas variáveis na Stack, no caso do Java.

Não é por haver um mecanismo de coleta de lixo que o programador não deva se preocupar com problemas de memória que um código, até mesmo um simples, pode causar.

Perdas de memória podem gerar uma OutOfMemoryError mas o maior problema é que, na maioria da vezes, ela ocorre de forma silienciosa. E apenas podem ser descobertas com uma inspeção minuciosa do código e com o auxílio de ferramentas de debugging, conhecidas como “heap profiler“.

A classe abaixo armazena um array de objetos, permite o push e o pop de elementos e a cada push, dobra de tamanho.

// Can you spot the "memory leak"?
public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}
public Object pop() {
if (size == 0)
throw new EmptyStackException();
return elements[--size];
}
/**
* Ensure space for at least one more element, roughly
* doubling the capacity each time the array needs to grow.
*/
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}

O problema dela é no método pop. Quando um objeto é retornado e o tamanho diminuído, a stack ainda mantém uma referência obsoleta a esse objeto. Nessa caso, toda referência que estiver fora da “porção ativa” do array serão obsoletos. A porção ativa equivale aos elementos que o índice for menor que o tamanho do array.

Perda de memórias em linguagens como o Java são também conhecidas como retenção não intencionais de objetos, ou “unintentional object retentions“. Esses objetos ficam excluídos do coleta de lixo assim como objetos que ele possa referênciar, e assim por diante.

E a solução? Tornar nulas as referências assim que um objeto se tornar obsoleto. Segue o treco do código com a solução.

public Object pop() {
if (size == 0)
throw new EmptyStackException();
Object result = elements[--size];
elements[size] = null; // Eliminate obsolete reference
return result;
}

Mas cuidado. Tornar nula referências a objetos deve ser exceção e não regra. E a melhor maneira de eliminar referências obsoletas é definar cada variável num menor escopo possível.

Então quando se deve usar o “null out”? Quais aspectos tornam uma classe suscetível a “memory leaks”? De maneira simples, sempre que houver uma espécie de memória e que seja gerida por ela. No caso da classe Stack, é o array de elementos e seus métodos para incluir e remover. O garbage collector não tem como saber se um elemento está inválido, uma vez que guarda a referência aos objetos e não eles em si. Portanto, isso deve ser feito manualmente pelo programador.

Até o próximo item.

Effective Java – Item 6

Avoid creating unnecessary objects (evite criar objetos desnecessários)

O item do livro diz que é mais apropriado reusar objetos ao invés de criar novos objetos funcionalmente equivalentes cada vez que for necessário. Um objeto pode sempre ser reutilizado se for imutável.

O primeiro exemplo dado é a crição de uma String.

String s = new String("bikini"); // DON'T DO THIS!

Esse código cria uma instância cada vez que é executado e nenhum deles é necessário. O argumento do construtor (“bikini”) já é uma String.

O correto é String s = "bikini";

Em um loop, nesse caso, apenas uma única instância é criado, ao invés de uma para cada vez que for executado.

E se na mesma VM outro objeto contendo “bikini” reusará a instância já criada.

O código abaixo, que verifica se uma String é um numeral romano, e da forma como foi escrito, criará sempre um Pattern para expressão regular, o que é muito caro para a VM.

// Performance can be greatly improved!
static boolean isRomanNumeral(String s) {
return s.matches("^(?=.)M*(C[MD]|D?C{0,3})"
+ "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
}

O certo seria criar um objeto imutável que seria reutilizado nas chamadas ao método.

// Reusing expensive object for improved performance
public class RomanNumerals {
private static final Pattern ROMAN = Pattern.compile(
"^(?=.)M*(C[MD]|D?C{0,3})"
+ "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
static boolean isRomanNumeral(String s) {
return ROMAN.matcher(s).matches();
}
}

 Esse código acima rodou 6.5 vezes mais rápido.

Um outro exemplo, que pode levar ao aumento de utilização de recursos, é utilizar o autoboxing, isto é, poder utilizar juntos primitivos e objetos que os encapsulam. Exemplo de long, primitivo, e Long, objeto.

// Hideously slow! Can you spot the object creation?
private static long sum() {
Long sum = 0L;
for (long i = 0; i <= Integer.MAX_VALUE; i++)
sum += i;
return sum;
}

O código acima criará 2^31 instâncias de Long desnecessárias. Desta forma, “prefira tipos primitivos a objetos que os encapsulem e tome cuidado nos autoboxing não intencionais”.

Essa parte do livro foi muito interessante pois são situações diárias e que se não forem observadas podem contribuir para diminuir a performance de aplicações.

Segue o link do livro.

 

SpringBoot @Async methods

Today I needed to implement a method to send a notification email after the registration progress. With the actual logic my application was taking too long during the process. So I decide to make the mail sending asynchronous.

First I tried the JMS, the old school Java Message Service API, but I realized that is not that gold, just old.

So after few googling I found a post of Dan Vega, a SpringBoot guru who has courses on Udemy.

With this post I realized: spring make our lives too easy, indeed.

Tow annotations make the method asynchronous, @Async and @EnableAsync.

Here is the post.

Java @Schedule error

I was trying to scheduling a method from a EJB class using the @Schedule annotation of the javax.ejb package.

@Schedule(second=”*/5″, minute=”*”, hour=”*”)
public void listarMsgs()
{
logger.log(Level.INFO, “do something…”);
}

But every time the method was called it  appeared a error like this:

Failed to reinstate timer…

Googling for about some time I figure out that it was a kind bug of the application server, JBoss Wildfly. I’m using the 9 version.

The solution was clear the folder under the standalone/data/timer-service-data that is where the server creates the xml of the schedule job.

Lambdas Oracle MOOC

Java 8 Lambda

Section 1

– Need changes to Java to simplify parallel coding.
– Lambda expressions simplify how to pass behavior as a parameter.

-Show the differences through Java basic code, inner classes and lambdas.

Non-functional (imperative) programming style versus functional.

Problem: external iteration.
After: more functional with inner classes;
And then: lambda approach, more concise, less code (error-prone), client logic is stateless, thread-safe.

The lambda expression provides the implementation of the abstract method. The type is the abstract method.

@FunctionalInterface -> Functional Interface = an interface with one abstract method; default doesn’t count. The equals also doesn’t count in therms of abstract method.

Variable assignment: Callable c = () -> process();

Method parameter: mew Thread(() -> process()).start();

Lambda expressions can be used anywhere the type is a functional interface.

– A functional interface has only one abstract method.

The lambda expression provides the implementation of the single abstract method of the functional interface.

java.util.function Package

Consumer<T>

Operation that takes a single value and return no result: String s -> System.out.println(s) .

Example: String s -> System.out.println(s);

BiConsumer<T,U>

Takes two values and returns no result.

Example: (k,v) -> System.out.println(“key: ” + k + “, value: ” + v);

Supplier

The opposite of a Consumer. Doesn’t take any parameter and returns a value.

Example: ( ) -> createLogMessage();

Function<T,R>

Takes one argument, do something and returns a result.

Example: Student s -> s.getName();

BiFunction<T,U,R>

Takes two arguments and returns a result.

Example: (String name, Student s) -> new Teacher(name, student);

UnaryOperator<T>

Kind function: single argument and result of the same type.

  • T apply(T a)

Example: String s -> s.toLowerCase();

BinaryOperartor<T>

Specialised form of BiFunction: two arguments and a result, all of the same type.

  • T apply(T a, T b)

Example: (String x, String y) -> { if (x.length() > y.length()) return x; return y; }

Predicate

A boolean valued function of one argument:

Example: Student s -> s.graduationYear() == 2011

BiPredicate

Takes two arguments

Example: (Student s, int minGrade) -> s.grade <= minGrade

Method and constructor references

FileFilter x = (File f) -> f.canRead();

FileFilter x = File::canRead;

External variables

Final or effective final.

Link to the on line free Oracle course.

10 Rules for Writing Safety Critical Code

In the current issue of Java Magazine the from editor column talks about the size of classes. The benefits of class with lines of code (LOCs) less than 60. But also some challenges that comes with.

What I found curious was a reference to 10 rules for writing safety critical code, that’s language agnostic. So it can be applied on actual Java projects without constraints. Other curious thing is that these rules are used by NASA, as describes the article.

The link for the rules is here.

The rule of limiting classes (functions at the original) to 60 lines of code is challenger and the article explain it very well.

Other important rules is the 10th: compile with all warnings enabled, and use one or more source code analyzers. Very actual.

So I thought that it was interesting and could open deeper discussions.

Infinitest

 

Mais uma ferramenta para otimizar o desenvolvimento e evitar a identificação tardia de bugs.

O Infinitest faz isso da seguinte forma: ao salvar uma alteração em um código na IDE ele dispara os testes, avalia e marca os que não passaram. Assim garante a verificação de erros on time.

No meu caso instalei-o no Eclipse (Mars.2 Release (4.5.2)), bem rápido e tranquilo pelo Marketplace.

Ainda pode ser configurado para excluir pacotes, classes ou padrões específicos criando um arquivo na raiz do projeto chamado infinitest.filters.

A documentação do projeto está aqui em https://infinitest.github.io/.

E a fonte deste post está no blog da Caelumn, aqui.

Até!

Apache Cassandra on Ubuntu

Cassandra logo

 

So I decided to test the NoSql Cassandra database. But to install was a non-trivial proccess on Ubuntu 16 release.

After some googling I found this link inside the Download area of the oficial Cassandra site. And then it works!

It was necessary to change the first key number for the one that is showing on the error after the apt-get update. I skipped the add of the other two keys and it works.

Now I can test the Cassandra with Spring Boot, via this link on Dzone.

Hope this can help…