‌            

Existem variáveis de diferentes tipos na linguagem C, como os ints, chars e floats. Todos permitem o armazenamento de dados.

Também temos os arrays, que permitem o agrupamento de itens de dados que possuem o mesmo tipo.

Porém, na realidade, nem sempre vamos ter o luxo de possuir dados de apenas um tipo. É nesse cenário que utilizamos as estruturas. Neste artigo, vamos aprender mais sobre tipos de dados estruturados em C.

Índice

A. Fundamentos

1. Definição e declaração
2. Inicialização e acesso aos membros de uma estrutura
3. Operações com uma variável de estrutura
4. Array de uma estrutura
5. Estruturas aninhadas

B. Alocação de memória

1. Alinhamento de dados
2. Preenchimento de estruturas
3. Alinhamento de membro de estrutura
4. Empacotamento de estrutura

C. Ponteiros

1. Ponteiro como um membro
2. Ponteiro para estrutura
3. Ponteiro e array de estrutura

D. Funções

1. Função como membro
2. Estrutura como argumento de função
3. Estrutura como retorno de uma função

E. Estrutura autorreferencial

F. Conclusão

Vamos começar!

Fundamentos

1. Definição e declaração

Uma estrutura é uma coleção de uma ou mais variáveis, possivelmente de tipos distintos, agrupadas em um nome comum. É um tipo de dado definido pelo usuário.

As estruturas auxiliam na organização de dados complicados em programas grandes, já que permitem com que um grupo de variáveis logicamente associadas entre si sejam tratadas desse modo.

Por exemplo, um estudante pode ter as propriedades nome, idade, sexo e notas. Podemos criar um array do tipo char para a variável nome, um int para matrícula, um char para sexo e um array do tipo int para as notas.

Porém, se existem 20 ou 100 estudantes, vai ser difícil lidar com essas variáveis.

Podemos declarar uma estrutura utilizando a palavra reservada struct de acordo com a sintaxe abaixo:

 /* Sintaxe */
 struct nomeEstrutura
        {
            tipoDado variavelMembro1;
            tipoDado variavelMembro2;
            ...
        };

 /* Exemplo */
struct estudante
    {
        char nome[20];
        int matricula;
        char sexo;
        int notas[5];
    };

O código acima define um novo tipo de dado, struct estudante. Cada variável pertencente a esse tipo de dado vai possuir um nome[20], matricula, sexo e notas[5]. Essas propriedades citadas são os membros da estrutura.

Uma vez que a estrutura é declarada como um novo tipo de dado, podemos criar as variáveis que possuem o tipo dessa estrutura.

 /* Declaração de variável */
struct nomeEstrutura variavelEstrutura;

 /* Exemplo /*
struct estudante est1;
struct estudante est2,est3,est4;

Cada variável de struct estudante tem sua própria cópia das propriedades membro.

Algumas informações importantes:

1. Os membros da estrutura não ocupam memória alguma até que uma variável de estrutura seja criada.
2. Você já deve ter notado que estamos usando a palavra struct para declarar a variável também. Não é um pouco tedioso?

Se utilizarmos a palavra reservada typedef na declaração da estrutura, podemos evitar a repetição da palavra struct.

typedef struct estudantes
    {
        char nome[20];
        int matricula;
        char sexo;
        int notas[5];
    } ESTUDANTE; 

/* ou */
typedef struct
    {
        char nome[20];
        int matricula;
        char sexo;
        int notas[5];
    } ESTUDANTE; 


ESTUDANTE est1,est2,est3,est4;

Como convenção, são utilizadas letras maiúsculas para definição de tipos (como ESTUDANTE).

3. A definição de estrutura e declaração de variável podem ser combinadas desta maneira:

struct estudante
    {
        char nome[20];
        int matricula;
        chat sexo;
        int notas[5];
    }est1, est2, est3, est4;

4. O uso de nomeEstrutura para declarar a estrutura é opcional. O código abaixo, por exemplo, é totalmente válido.

struct
    {
        char nome[20];
        int matricula;
        char sexo;
        int notas[5];
    }est1, est2, est3, est4;

5.  Estruturas geralmente são declaradas no começo do arquivo do código-fonte, antes mesmo das definições das funções (você já vai ver o motivo).

6.  A linguagem C não permite a inicialização de uma variável dentro da declaração de uma estrutura.

2. Inicialização e acesso aos membros de uma estrutura

Como qualquer outra variável, uma variável de estrutura também pode ser inicializada na mesma linha onde foi declarada.

 /* Inicialização de variável */
nomeEstrutura nomeVariavel = { valor1, valor2,...};

 /* Exemplo */
typedef struct
    {
        char nome[20];
        int matricula;
        char sexo;
        int notas[5];
    }ESTUDANTE;

void main(){
ESTUDANTE est1 = { "Alex", 43, 'M', {76, 78, 56, 98, 92}};
ESTUDANTE est2 = { "Max", 33, 'M', {87, 84, 82, 96, 78}};
}

Para acessar os membros, precisamos usar o . (operador de ponto)

 /* Acessando os membros de uma estrutura */
variavelEstrutura.membroVariavel;

/* Exemplo */
 printf("Nome: %s\n", est1.nome);
 printf("Matricula: %d\n", est1.matricula);
 printf("Sexo: %c\n", est1.sexo);
 for( int i = 0; i < 5; i++)
   printf("Notas na matéria n°%d: %d\n", i, est1.notas[i]);

/* Saída */
Nome: Alex
Matricula: 43
Sexo: M
Notas na matéria n°0: 73
Notas na matéria n°1: 78
Notas na matéria n°2: 56
Notas na matéria n°3: 89
Notas na matéria n°4: 92

Os membros podem ser inicializados na declaração da variável em qualquer ordem, apenas utilizando o ..

ESTUDANTE est3 = { .sexo = 'M', .matricula = 23, .nome = "Gasly", .notas = { 99, 45, 67, 78, 94}};

Também podemos inicializar os primeiros membros e deixar os membros restantes vazios. Contudo, os membros que não foram inicializados devem estar somente no final da lista.

Inteiros e números de ponto flutuante que não foram inicializados tem um valor padrão 0. Enquanto que caracteres e strings não inicializados possuem o valor padrão \0 (NULL) .

ESTUDANTE est4 = { "Mário", 65};
 /* Equivalente a { "Mario", 65, '\0', { 0, 0, 0, 0, 0} } */

3. Operações com a variável de estrutura

Ao contrário das variáveis de tipos primitivos, não podemos utilizar operadores aritméticos como +, -, *, / para variáveis de estrutura. Também não é possível o uso de operadores relacionais e de igualdade.

Contudo, podemos copiar uma variável de estrutura para outra, desde que pertençam à mesma estrutura.

 /* Operações inválidas */
est1 + est2
est1 - est2
est1 == est2
est1 != est2

 /* Operação válida */
est1 = est2

Para comparar as variáveis de estrutura, vamos comparar os membros de cada uma individualmente.

#include <stdio.h>
#include <string.h>

 struct estudante
    {
        char nome[20];
        double matricula;
        char sexo;
        int notas[5];
    }est1,est2;


void main()
{
    struct estudante est1= { "Alex", 43, 'M', {76, 78, 56, 98, 92}};
    struct estudante est2 = { "Max", 33, 'M', {87, 84, 82, 96, 78}};

    if( strcmp(est1.nome,est2.nome) == 0 && est1.matricula == est2.matricula)
        printf("Os dois dados pertencem ao mesmo estudante.\n");
    else printf("Dados diferentes, estudantes diferentes.\n");

     /* Copiando a variável de estrutura */
    est2 = est1;

    if( strcmp(est1.name,est2.name) == 0 && est1.matricula == est2.matricula)
        printf("Os dois dados pertencem ao mesmo estudante.\n");
    else printf("Dados diferentes, estudantes diferentes.\n");
}

 /* Saida */
Os dois dados pertencem ao mesmo estudante.

Dados diferentes, estudantes diferentes.

4. Array de uma estrutura

Você deve ter percebido que criamos 4 variáveis diferentes do tipo struct student para armazenar os dados de 4 estudantes.

Uma maneira melhor de armazenar esses dados seria criar um array de struct student (da mesma maneira que um array de ints )

struct estudante
    {
        char nome[20];
        double matricula;
        char sexo;
        int notas[5];
    };

struct estudante estu[4];

Para acessar os elementos do array estu e os membros de cada elemento, podemos utilizar laços de repetição (loops).

 /* Registrando valores para os estudantes */

for(int i = 0; i < 4; i++)
    {
        printf("Digite o nome:\n");
        scanf("%s",&estu[i].nome);
        printf("Digite a matrícula:\n");
        scanf("%d",&estu[i].matricula);
        printf("Digite o sexo:\n");
        scanf(" %c",&estu[i].sexo);

        for( int j = 0; j < 5; j++)
        {
            printf("Digite as notas da matéria n°%d:\n",j);
            scanf("%d",&estu[i].notas[j]);
        }

        printf("\n-------------------\n\n");
    }

 /* Calculando a média de notas e imprimindo o resultado */

for(int i = 0; i < 4; i++)
    {
        float soma = 0;
        for( int j = 0; j < 5; j++)
        {
            soma += estu[i].notas[j];
        }

        printf("Nome: %s\nMédia = %.2f\n\n", estu[i].nome,soma/5);
    }

5. Estruturas aninhadas

Aninhar uma estrutura significa ter uma ou mais variáveis de estrutura dentro de uma outra estrutura. Do mesmo modo com que declaramos um membro do tipo int ou um membro do tipo char, podemos também declarar uma variável de estrutura como um membro.

struct nascimento
    {
       int dia;
       int mes;
       int ano;
    };

struct estudante
    {
        char nome[20];
        int matricula;
        char sexo;
        int notas[5];
        struct nascimento dataNascimento;
    };

void main(){
 struct estudante estu1;

A variável de estrutura dataNascimento de tipo struct nascimento está aninhada dentro de struct estudante. É importante frisar que você não consegue aninhar uma variável de estrutura do tipo struct estudante dentro de struct estudante.

Perceba que a estrutura que vai ser aninhada deve ser declarada antes. Usando o ., podemos acessar os membros contidos dentro da estrutura interna, assim como os outros membros.

 /* Exemplo */
estu1.dataNascimento.dia
estu1.dataNascimento.mes
estu1.dataNascimento.ano
estu1.nome

Variáveis de estrutura de diferentes tipos podem ser aninhadas.

struct nascimento
    {
       int dia;
       int mes;
       int ano;
    };
 
struct parentesco
    {
        char nomePai[20];
        char nomeMae[20];
    };

struct estudante
    {
        char nome[20];
        int matricula;
        char sexo;
        int notas[5];
        struct nascimento dataNascimento;
        struct parentesco pais;
    };

Alocação de memória

Quando uma variável de estrutura de um certo tipo é declarada, os membros da estrutura são alocados em memória de maneira contígua (adjacente).

struct estudante
    {
        char nome[20];
        int matricula;
        char sexo;
        int notas[5];
    } estu1;

Aqui, haverá memória sendo alocada para nome[20, seguido de matricula, sexo, e notas[5]. Isso implica que o tamanho de estu1 ou de struct estudante será a soma do tamanho dos membros, certo? Vamos dar uma olhada.

void main()
{
    printf("Soma do tamanho dos membros = %I64d bytes\n", sizeof(estu1.nome) + sizeof(estu1.matricula) + sizeof(estu1.sexo) + sizeof(estu1.notas));
    printf("Usando o operador sizeof() = %I64d bytes\n",sizeof(estu1));
}

 /* Saída */
Soma do tamanho dos membros =  45 bytes
Usando o operador sizeof() = 48 bytes

Já que o operador sizeof() retorna um long long unsigned int, utilize %I64D para especificar o formato. Você talvez precise usar %llu ou lld, dependendo do seu compilador.

Usar %d retornará um aviso -  format '%d' expects argument of type 'int', but argument 2 has type 'long long unsigned int'. (formato '%d' pede um argumento do tipo 'int', mas o argumento 2 tem tipo 'long long unsigned int').

Utilizando o operador sizeof() na variável de estrutura, tivemos 3 bytes a mais do que a soma do tamanho dos membros. Por que? Onde estão esses 3 bytes na memória?

Vamos responder à segunda pergunta primeiro. Podemos imprimir os endereços de memória dos membros para achar estes 3 bytes.

void main()
{
    printf("Endereço do membro 'nome' = %d\n", &estu1.nome);
    printf("Endereço do membro 'matricula' = %d\n", &estu1.matricula);
    printf("Endereço do membro 'sexo' = %d\n", &estu1.sexo);
    printf("Endereço do membro 'notas' = %d\n", &estu1.notas);
}

 /* Saída */
Endereço do membro 'nome' = 4225408
Endereço do membro 'matricula' = 4225428
Endereço do membro 'sexo' = 4225432
Endereço do membro 'notas' = 4225436

Podemos ver que o array notas[5], ao invés de estar sendo alocado no endereço 4225433, está no endereço 4224536. Por que isso ocorre?

1. Alinhamento de dados

Antes de darmos uma olhada no alinhamento de dados, é importante entender como o processador lê dados da memória.

Um processador lê uma palavra em um ciclo. Essa palavra possui 4 bytes para um processador de 32 bits e 8 bytes para um de 64 bits. Quanto menor o número de ciclos, melhor o desempenho da CPU.

Um modo de alcançar um menor número de ciclos é por meio do alinhamento de dados. Na prática, alinhar é quando uma variável de tamanho t de um tipo primitivo qualquer é armazenada em um endereço que é múltiplo de t.  Esse processo ocorre por padrão.

Endereços alinhados para certos tipos de dados

2. Preenchimento de estruturas

Talvez você precise inserir alguns bytes extras entre os membros da estrutura para poder alinhar dados. Esses bytes extras são conhecidos como preenchimento (padding).

No código acima, os 3 bytes acrescentados foram o preenchimento. Sem este preenchimento, notas[0], que é de tipo int (endereço múltiplo de 4), teria seu endereço como 4225433 (não múltiplo de 4).

Você provavelmente já deve ter percebido por que estruturas não podem ser comparadas diretamente.

3. Alinhamento de membro de estrutura

Para explicar este tópico, vamos para outro exemplo (você vai entender o por quê).

struct exemplo
    {
        int i1;
        double d1;
        char c1;
        
    } exemplo1;

void main()
{
    printf("tamanho = %I64d bytes\n",sizeof(exemplo1));
}

Qual seria a saída desse programa? Vamos aplicar nossos conhecimentos.

i1 possui 4 bytes. Essa variável vai ser seguida de um preenchimento de 4 bytes porque o endereço de d1 deve ser divisível por 8.

Isso será seguido de 8 e 1 byte respectivamente para d1 e c1. Logo, a saída deve ser 4 + 4 + 8 + 1 = 17 bytes.

 /* Saída */
tamanho = 24 bytes

O quê?! Errado de novo! Por quê? Através de um array de tipo struct exemplo, podemos entender melhor. Também vamos imprimir o endereço dos membros de exemplo2[0].

void main()
{
    struct exemplo exemplo2[2];
    printf("Endereço de exemplo2[0].i1 = %d\n", &exemplo2[0].i1);
    printf("Endereço de exemplo2[0].d1 = %d\n", &exemplo2[0].d1);
    printf("Endereço de exemplo2[0].c1 = %d\n", &exemplo2[0].c1);

}

 /* Saída */
Endereço de exemplo2[0].i1 = 4225408
Endereço de exemplo2[0].d1= 4225416
Endereço de exemplo2[0].c1 = 4225424

Vamos supor que o tamanho de exemplo2[0] é 17 bytes. Isso implica que o endereço de exemplo2[1].i1 será 4225425. Isso não é possível já que o endereço de um int deve ser múltiplo de 4.

Logicamente, um endereço possível para exemplo2[1].i1 pode ser 4225428, um múltiplo de 4.

Isso também está errado. Você sabe o por quê? O endereço de exemplo2[1].d1 agora será (28 + 4 (i1) + 3 (preenchimento)) 4225436, que não é um múltiplo de 8.

Para que possamos evitar o desalinhamento, o compilador aplica alinhamento em toda estrutura. Isso é feito ao adicionar bytes extra após o último membro, processo conhecido como alinhamento de membro de estrutura.

No exemplo que discutimos no começo desta seção, isso não era necessário (por isso, precisamos de outro exemplo.)

Uma maneira simples de lembrar deste conceito é por meio desta regra: o endereço e tamanho da estrutura devem ser múltiplos de t_max, onde t_max é o tamanho máximo que um membro da estrutura ocupa.

No caso de struct exemplo, 8 bytes é o tamanho máximo de d1. Portanto, haverá um preenchimento de 7 bytes no fim da estrutura, fazendo com que seu tamanho seja de 24 bytes.

Seguindo as duas regras abaixo, você pode facilmente encontrar o tamanho de qualquer estrutura:

1. Todo tipo de dado armazena seu valor em um endereço que é múltiplo de seu tamanho.
2. Toda estrutura ocupa um tamanho que é múltiplo do tamanho máximo de bytes que um membro ocupa.

Apesar de sermos capazes de diminuir os ciclos de uma CPU, existe uma quantidade significativa de memória que será desperdiçada.

Uma maneira de diminuir a quantidade de preenchimento para o mínimo possível é declarando os membros em ordem decrescente de tamanho.

Se aplicarmos este método em struct exemplo, o tamanho da estrutura é reduzido para 16 bytes. O preenchimento é reduzido de 7 para 3 bytes.

struct exemplo
    {
        double d1; 
        int i1;
        char c1;
        
    } exemplo3;

void main()
{
    printf("tamanho = %I64d bytes\n",sizeof(exemplo3));
}

 /* Saída */
tamanho = 16 bytes

4. Empacotamento de estrutura

Empacotar (packing) é o oposto de preencher. Empacotar previne o compilador de preencher e remove a memória não alocada.

No caso do Windows, podemos usar a diretiva #pragma pack, que especifica o empacotamento de membros de estrutura.

#pragma pack(1)

struct exemplo
    {
        double d1; 
        int i1;
        char c1;
        
    } exemplo4;

void main()
{
    printf("tamanho = %I64d bytes\n",sizeof(exemplo4));
}

 /* Saída */
tamanho = 13 bytes

Isso garante que os membros da estrutura estejam alinhados em um limite de 1 byte. Em outras palavras, o endereço de qualquer tipo de dado deve ser um múltiplo ou de 1 byte ou do seu tamanho (depende de qual for o menor).

Ponteiros

Se quiser repassar o conteúdo sobre ponteiros antes de seguir em frente com o artigo, aqui está um link que cobre ponteiros de maneira aprofundada (texto em inglês).

1. Ponteiro como um membro

Uma estrutura pode ter ponteiros como membros.

struct estudante
    {
        char *nome;
        int *matricula;
        char sexo;
        int notas[5];
    };

void main()
{   int alexMatricula = 44;
   struct estudante estu1 = { "Alex", &alexMatricula, 'M', { 76, 78, 56, 98, 92 }};
}

Utilizando o . (operador ponto), podemos novamente acessar os membros. Já que matricula agora tem o endereço de alexMatricula, teremos que desreferenciar estu1.matricula (e não estu1.(*matricula)) para obter o valor

 printf("Nome: %s\n", estu1.nome);
   printf("Matrícula: %d\n", *(estu1.matricula));
   printf("Sexo: %c\n", estu1.sexo);

   for( int i = 0; i < 5; i++)
    printf("Notas na matéria %d: %d\n", i, estu1.notas[i]);

 /* Saída */
Nome: Alex
Matrícula: 43
Sexo: M
Notas na matéria 0: 76
Notas na matéria 1: 78
Notas na matéria 2: 56
Notas na matéria 3: 98
Notas na matéria 4: 92

2. Ponteiro para estrutura

Assim como ponteiros de inteiros, ponteiros de arrays e ponteiros de funções, temos ponteiros para estruturas também.

struct estudante {
    char nome[20];
    int matricula;
    char sexo;
    int notas[5];
};

struct estudante estu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};

struct estudante*ptrEstu1 = &estu1;

Declaramos o ponteiro ptrEstu1 do tipo struct estudante. Definimos o endereço de estu1 para ptrEstu1.

ptrEstu1 armazena o endereço base de estu1, que é o endereço base do primeiro membro da estrutura. Incrementar em 1 aumentaria o endereço em sizeof(estu1) bytes.

printf("Endereço da estrutura = %d\n", ptrEstu1);
printf("Endereço do membro `nome` = %d\n", &estu1.nome);
printf("Incrementar em 1 resulta em %d\n", ptrEstu1 + 1);

/* Saída */
Endereço da estrutura = 6421968
Endereço do membro `nome` = 6421968
Incrementar em 1 resulta em 6422016

Podemos acessar os membros de estu1 usando ptrEstu1 de duas formas. Usando * (operador de indireção) ou usando -> (operador infix ou arrow).

Com *, continuaremos usando o . (operador ponto) enquanto que com -> não precisaremos do operador de ponto.

printf("Nome sem usar ptrEstu1 : %s\n", estu1.nome);
printf("Nome usando ptrEstu1 e * : %s\n", (*ptrEstu1).nome);
printf("Nome usando ptrEstu1 e -> : %s\n", ptrEstu1->nome);

/* Output */
Nome sem usar ptrEstu1 : Alex
Nome usando ptrEstu1 e * : Alex
Nome usando ptrEstu1 e -> : Alex

De modo similar, podemos acessar e modificar outros membros também. Note que os parênteses são necessários enquanto utilizamos o * já que o operador de ponto (.) tem procedência maior que *.

3. Ponteiro e array de estrutura

Podemos criar um array do tipo struct estudante e usar um ponteiro para acessar os elementos e seus membros.

struct estudante estu[10];

 /* Ponteiro para o primeiro elemento (estrutura) do array */
struct estudante *ptrEstu_tipo1 = estu;

 /* Ponteiro para um array de tamanho 10 do tipo struct estudante */
struct estudante (*ptrEstu_tipo2)[10] = &estu;

Note que ptrEstu_tipo1 é um ponteiro para estu[0], enquanto que ptrEstu_tipo2 é um ponteiro para o array inteiro de tamanho 10 e tipo struct estudante. Adicionar 1 a ptrEstu_tipo1 apontaria para estu[1].

Podemos usar ptrEstu_tipo1 com um laço de repetição (ou loop) para percorrer os elementos e seus membros.

for( int i = 0; i <  10; i++)
printf("%s, %d\n", ( ptrEstu_tipo1 + i)->nome, ( ptrEstu_tipo1 + i)->matricula);

Funções

1. Função como membro

Funções não podem ser membro de uma estrutura. Contudo, utilizando ponteiros de função, podemos chamar funções utilizando .. Apenas tenha em mente que isso não é recomendado.

 struct exemplo
    {
        int i;
        void (*ptrMensagem)(int i);


    };

void mensagem(int);

void mensagem(int i)
{
    printf("Olá, eu sou um membro de uma estrutura. Esta estrutura também tem um inteiro de valor %d", i);
}

void main()
{
    struct exemplo eg1 = {6, mensagem};
    eg1.ptrMensagem(eg1.i);
}

Declaramos dois membros, um inteiro i e um ponteiro de função ptrMensagem dentro de struct exemplo. O ponteiro de função aponta para uma função que recebe um inteiro e retorna void.

mensagem é esta função. Inicializamos eg1 com valor 6 e mensagem. Depois usamos . para chamar a função usando ptrMensagem e passar como valor eg1.i.

2. Estrutura como argumento de função

Assim como variáveis, podemos passar membros individuais de estruturas como argumentos.

#include <stdio.h>

struct estudante {
    char nome[20];
    int matricula;
    char sexo;
    int notas[5];
};

void display(char a[], int b, char c, int notas[])
{
    printf("Nome: %s\n", a);
    printf("Matrícula: %d\n", b);
    printf("Sexo: %c\n", c);

    for(int i = 0; i < 5; i++)
        printf("Notas na matéria %d: %d\n",i,notas[i]);
}
void main()
{
    struct estudante estu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};
    display(estu1.nome, estu1.matricula, estu1.sexo, estu1.notas);
}

 /* Saída */
Nome: Alex
Matrícula: 43
Sexo: M
Notas na matéria 0: 76
Notas na matéria 1: 98
Notas na matéria 2: 68
Notas na matéria 3: 87
Notas na matéria 4: 93

Note que a estrutura struct estudante é declarada dentro de main(), logo no começo. Isto é para assegurar que ela estará disponível globalmente e que display() possa usá-la.

Se a estrutura for definida dentro de main(), seu escopo estará limitado somente à main().

Passar membros de estrutura como argumento não é muito eficiente quando temos um número grande deles. Então, variáveis de estrutura podem ser passadas para uma função.

void display(struct estudante a)
{
    printf("Nome: %s\n", a.nome);
    printf("Matrícula: %d\n", a.matricula);
    printf("Sexo: %c\n", a.sexo);

    for(int i = 0; i < 5; i++)
        printf("Notas na matéria %d: %d\n",i,a.notas[i]);
}
void main()
{
    struct estudante estu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};
    display(estu1);
}

Se o tamanho da estrutura é muito grande, então passar uma cópia dela será ineficiente. Poderíamos passar um ponteiro de estrutura para uma função. Nesse caso, o endereço da estrutura será passado como um argumento de fato.

void display(struct estudante *p)
{
    printf("Nome: %s\n", p->nome);
    printf("Matrícula: %d\n", p->matricula);
    printf("Sexo: %c\n", p->sexo);

    for(int i = 0; i < 5; i++)
        printf("Notas na matéria %d: %d\n",i,p->notas[i]);
}
void main()
{
    struct estudante estu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};
    struct estudante *ptrEstu1 = &estu1;
    display(ptrEstu1);
}

Passar um array de estrutura para uma função é semelhante a passar um array de qualquer tipo a uma função. O nome do array, que é o endereço base do array da estrutura, é passado à função.

void display(struct estudante *p)
{   
    for( int j = 0; j < 10; j++)
   {
       printf("Nome: %s\n", (p+j)->nome);
        printf("Matrícula: %d\n", (p+j)->matricula);
        printf("Sexo: %c\n", (p+j)->sexo);

        for(int i = 0; i < 5; i++)
        printf("Notas na matéria %d: %d\n",i,(p+j)->notas[i]);
   }
}

void main()
{
    struct estudante estu1[10];
    display(estu1);
}

3. Estrutura como retorno de função

Podemos retornar uma variável de estrutura, assim como qualquer outra variável.

#include <stdio.h>

struct estudante {
    char nome[20];
    int matricula;
    char sexo;
    int notas[5];
};


struct estudante incrementaEm5(struct estudante p)
{
    for( int i =0; i < 5; i++)
        if(p.notas[i] + 5 <= 100)
           {
               p.notas[i]+=5;
           }
    return p;
}

void main()
{
    struct estudante estu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}};
    estu1 = incrementaEm5(estu1);
    
    printf("Nome: %s\n", estu1.nome);
    printf("Matrícula: %d\n", estu1.matricula);
    printf("Sexo: %c\n", estu1.sexo);
    
     for(int i = 0; i < 5; i++)
        printf("Nota na matéria %d: %d\n",i,estu1.notas[i]);
}

 /* Saída */
Nome: Alex
Matrícula: 43
Sexo: M
Notas na matéria 0: 81
Notas na matéria 1: 98
Notas na matéria 2: 73
Notas na matéria 3: 92
Notas na matéria 4: 98

A função incrementaEm5() soma 5 à todas as notas de matérias que, após a soma, sejam menores ou iguais a 100. Note que o tipo de retorno é uma variável de estrutura do tipo struct estudante.

Enquanto retorna um membro de estrutura, o tipo de retorno deve ser o mesmo que o do membro.

Um ponteiro de estrutura também pode ser retornado por uma função.

#include <stdio.h>
#include <stdlib.h>

struct retangulo {
    int tamanho;
    int amplitude;
};

struct retangulo* function(int tamanho, int amplitude)
{
    struct retangulo *p  = (struct retangulo *)malloc(sizeof(struct retangulo));
     p->tamanho = tamanho;
     p->amplitude = amplitude;
    return p;
}

void main()
{
    struct retangulo *retangulo1 = function(5,4);
    printf("Tamanho do retangulo = %d unidades\n", retangulo1->tamanho);
    printf("Amplitude do retangulo = %d unidades\n", retangulo1->amplitude);
    printf("Área do retangulo = %d unidades quadradas\n", retangulo1->length * retangulo1->amplitude);
}

 /* Saída */
Tamanho do retangulo = 5 unidades
Amplitude do retangulo = 4 unidades
Area do retangulo = 20 unidades quadradas

Note que alocamos a memória de tamanho struct retangulo de forma dinâmica usando malloc(). Já que essa função retorna um ponteiro void, temos que utilizar typecast para transformar este retorno em um ponteiro do tipo struct retangulo.

Estrutura autorreferencial

Vimos que ponteiros podem ser um membro de uma estrutura também. O que ocorre, porém, se o ponteiro for um ponteiro de estrutura? O ponteiro pode ser tanto do mesmo tipo da estrutura ou diferente.

Estruturas autorreferenciais são aquelas que possuem ponteiro(s) de estrutura do mesmo tipo do seu(s) membro(s).

struct estudante {
    char nome[20];
    int matricula;
    char sexo;
    int notas[5];
    struct estudante *next;
 };

Essa é uma estrutura autorreferencial onde next é um ponteiro de estrutura do tipo struct estudante.

Agora, vamos criar duas estruturas de variáveis estu1 e estu2 e inicializá-las. Depois, vamos armazenar o endereço de estu2 no membro next de estu1.

void main()
{
    struct estudante estu1 = {"Alex", 43, 'M', {76, 98, 68, 87, 93}, NULL};
    struct estudante estu2 = { "Max", 33, 'M', {87, 84, 82, 96, 78}, NULL};
    estu1.next = &estu2;
}

Isso nos permite acessar os membros de estu2 usando estu1 e next.

void main()
{
    printf("Nome: %s\n", estu1.next->nome);
    printf("Matrícula: %d\n", estu1.next->matricula);
    printf("Sexo: %c\n", estu1.next->sexo);

    for(int i = 0; i < 5; i++)
        printf("Notas na matéria %d: %d\n",i,estu1.next->notas[i]);
}

 /* Saída */
Nome: Max
Matrícula: 33
Sexo: M
Notas na matéria 0: 87
Notas na matéria 1: 84
Notas na matéria 2: 82
Notas na matéria 3: 96
Notas na matéria 4: 78

Suponha que queremos uma estrutura de variável diferente após stu1, ou seja, inserir outra estrutura de variável entre estu1 e estu2. Isso pode ser feito facilmente.

void main()
{
    struct estudante estuBetween = { "Gasly", 23, 'M', {83, 64, 88, 79, 91}, NULL};
    est1.next = &estuBetween;
    estuBetween.next = &estu2;
}

Agora estu1.next armazena o endereço de estuBetween. E estuBetween.next tem o endereço de estu2. Podemos, agora, acessar todas as três estruturas usando estu1.

  printf("Matrícula de %s: %d\n", estu1.next->nome, estu1.next->matricula);
    printf("Sexo de %s: %c\n", estu1.next->next->nome, estu1.next->next->sexo);

 /* Saída */
Matrícula de Gasly: 23
Sexo de Max: M

Note como formamos uma ligação entre estu1, estuBetween e estu3. O que discutimos aqui foi o começo de uma Lista Ligada (Linked List)

Estruturas autorreferenciais são muito úteis na criação de estruturas de dados como a própria lista ligada, pilhas, filas, grafos e daí por diante.

Conclusão

Feito! Abordamos tudo, desde a definição do que é uma estrutura, até o uso de estruturas autorreferenciais.

Tente revisar todos os subtópicos que você ler. Se conseguir lembrá-los, parabéns! Leia os que não conseguir lembrar novamente.

O próximo passo lógico seria aprender mais sobre listas ligadas e outras várias estruturas de dados que foram usadas aqui.

Continue aprendendo.

Em um artigo anterior (em inglês), escrevi sobre a Máquina Virtual do Java (JVM) e expliquei sua arquitetura. Como parte do componente de ferramenta de execução, eu também falei brevemente sobre o Coletor de Lixo do Java (em inglês, Garbage Collector, ou GC).

Neste artigo, você vai aprender mais sobre o Garbage Collector, como ele funciona, os tipos variados de GC presentes no Java e suas vantagens. Também comentarei alguns dos novos Coletores de Lixo experimentais que estão disponíveis nas últimas versões do Java.

O que é a coleta de lixo em Java?

A coleta de lixo é o processo de recolher a memória não utilizada em tempo de execução, destruindo os objetos inutilizados.

Em linguagens como C e C++, o programador é responsável tanto pela criação quanto pela destruição dos objetos. Às vezes, o programador pode esquecer de destruir objetos que não estão sendo utilizados. A memória alocada para eles, por isso, não é liberada. A memória utilizada pelo sistema continua crescendo e, em algum momento, não haverá memória disponível no sistema para alocar seus objetos. O nome dado a tal processo é "memory leak" (vazamento de memória).

Após um certo ponto, a memória suficiente não se encontra disponível para a criação de objetos. O programa inteiro, então, finaliza anormalmente devido a um erro do tipo OutOfMemoryError.

Você pode usar métodos como free() em C e delete() em C++ para realizar operações de coleta de lixo. Em Java, porém, a coleta de lixo acontece automaticamente durante o ciclo de vida de um programa. Isso elimina a necessidade de desalocar memória e, portanto, evita vazamentos de memória.

O Garbage Collector do Java é o processo no qual os programas em Java realizam o gerenciamento automático de memória. Programas em Java são compilados em bytecode, podendo ser executados na Máquina Virtual do Java (Java Virtual Machine).

Quando estes programas são executados na JVM, objetos são criados na memória heap, que é a porção da memória dedicada ao programa.

No decorrer do ciclo de vida de uma aplicação em Java, objetos são criados e dispensados. Ao final, alguns objetos não são mais necessários. É possível dizer que, a qualquer ponto, a memória heap consiste em dois tipos de objetos:

• Vivos (Live) – estes objetos estão sendo utilizados e referenciados em algum lugar
• Mortos (Dead) – estes objetos não estão sendo utilizados ou não estão sendo referenciados em lugar algum.

O coletor de lixo encontra esses objetos que não estão sendo utilizados e os exclui para salvar memória.

Como desreferenciar um objeto em Java

O objetivo principal do coletor de lixo é salvar espaço na memória heap por meio da destruição de objetos que não contêm uma referência. Quando não existem referências a um objeto, a JVM pressupõe que o mesmo está morto (dead) e que não é mais necessário. Então, a memória heap ocupada por este objeto pode ser desocupada.

Existem diversas formas pelas quais as referências de um objeto podem ser desfeitas para transformá-lo em um candidato à coleta de lixo. Algumas delas são:

Transformar uma referência em nula

Estudante estudante = new Estudante();
estudante = null;

Atribuir uma referência à outra

Estudante estudanteUm = new Estudante();
Estudante estudanteDois = new Estudante();
estudanteUm = estudanteDois; // agora o primeiro objeto referenciado por estudanteUm está disponível para garbage collection

Utilizar um objeto anônimo

registrar(new Estudante());

Como funciona o Garbage Collection em Java?

O Garbage Collection do Java é um processo automático. O programador não precisa marcar explicitamente os objetos a serem excluídos.

A implementação da coleta de lixo se encontra na JVM (Máquina Virtual do Java). Cada JVM pode implementar sua própria versão de Garbage Collection. Porém, essa versão deve atender aos padrões da especificação da JVM de trabalhar com objetos presentes na memória heap, marcar ou identificar os objetos inalcançáveis, e destruí-los com compactação.

O que são as roots de Garbage Collection em Java?

Coletores de lixo funcionam sob o conceito de Garbage Collection Roots (GC Roots) para identificar objetos vivos e mortos.

Exemplos dessas roots de Garbage Collection são:

• Classes executadas pelo executor de classes do sistema (com exceção dos executores de classes customizadas)
• Threads ativas
• Variáveis locais e parâmetros dos métodos em execução
• Variáveis locais e parâmetros de métodos JNI (Java Native Interface)
• Referências globais de JNI
• Objetos utilizados como monitores para sincronização
• Objetos mantidos da coleta de lixo pela JVM para seus fins

O coletor de lixo percorre todo o grafo de objetos na memória, começando pelas roots de Garbage Collection e referências posteriores às roots de outros objetos.

Etapas de coleta de lixo em Java

Uma implementação padrão de coletor de lixo envolve três etapas:

Marcar objetos como vivos

Nessa etapa, o GC identifica todos os objetos vivos na memória ao percorrer o grafo de objetos.

Quando o GC "visita" um objeto, o marca como acessível – logo, ele está vivo. Todo objeto que o GC visita é marcado como vivo. Todos os objetos que não podem ser visitados pelas roots do GC são lixo e considerados como candidatos para coleta.

Se livrar de objetos mortos

Após a fase de marcação, temos um espaço na memória que é ocupado tanto por objetos vivos (visited), quanto por objetos mortos (unvisited). A fase de "livração" libera fragmentos de memória que contêm objetos mortos.

Compactar os objetos restantes na memória

Os objetos mortos que são removidos durante a fase de liberação não precisam necessariamente estar um ao lado do outro. Portanto, você pode acabar tendo espaços de memória fragmentados.

A memória, então, pode ser compactada depois que o coletor de lixo excluir os objetos mortos, para que os objetos remanescentes estejam em um bloco contíguo no começo da memória heap.

O processo de compactação faz com que seja mais fácil alocar memória para novos objetos de forma sequencial.

O que é a coleta de lixo geracional em Java?

Os coletores de lixo em Java implementam uma estratégia chamada coleta de lixo geracional, que categoriza objetos por idade.

Ter que marcar e compactar todos os objetos em uma JVM é ineficiente. Quanto mais e mais objetos são alocados, a lista de objetos cresce, levando a um tempo de coleta mais longo. A análise empírica de aplicações têm mostrado que a maioria dos objetos em Java têm vida curta.

No exemplo acima, o eixo Y representa o número de bytes alocados. O eixo X representa o tempo. Como você pode ver, menos e menos objetos permanecem alocados com o passar do tempo.

Na verdade, a maioria dos objetos têm uma vida muito curta, como foi demonstrado pelos altos valores no lado esquerdo do gráfico. É por isso que o Java categoriza e realiza coleta de lixo de acordo com as gerações de objetos.

A área da memória heap na JVM é dividida em três seções:

Geração jovem

Objetos recentemente criados começam na geração jovem (Young Generation). Esta geração é subdividida em:

• Espaço Éden (EdenSpace) – todos os novos objetos começam aqui, e a memória inicial é alocada neles.
• Espaço de sobreviventes (FromSpace e ToSpace) – objetos são movidos daqui para o Éden após um ciclo de coleta.

Quando objetos são coletados a partir da Geração Jovem, é um evento menor de coleta de lixo.

Quando o Espaço Éden é preenchido por objetos, um evento menor de Garbage Collection é realizado. Todos os objetos mortos são excluídos e todos os objetos vivos são movidos para um dos Espaços de sobreviventes.  Coletas de lixo menores também verificam os objetos em um espaço de sobreviventes e os movem para outro espaço.

Tenha a seguinte sequência como exemplo:

1. O Éden tem todos os objetos (vivos e mortos)
2. Uma Coleta de Lixo menor ocorre – todos os objetos mortos são removidos do Éden. Todos os objetos vivos são movidos para o S1 (FromSpace). O Éden e o S2 agora estão vazios.
3. Objetos são criados e adicionados ao Éden. Alguns objetos neste espaço e no S1 se tornam mortos.
4. Outro evento menor de GC ocorre – todos os objetos mortos são removidos do Éden e do S1. Todos os objetos vivos são movidos para o S2 (ToSpace). Eden e S1 agora estão vazios.

Portanto, em qualquer momento, um dos espaços de sobreviventes está vazio. Quando os objetos sobreviventes alcançam uma certa "experiência" em serem movidos entre os espaços de sobreviventes diversas vezes, eles são transferidos à Geração Velha.

Você pode usar a flag `-Xmn` para definir o tamanho da Geração Jovem.

Geração velha

Objetos que são mais velhos são eventualmente movidos da Geração Jovem para a Geração Velha (Old Generation). Esta geração também é referenciada como Tenured Generation, e contêm objetos que continuaram nos espaços de sobreviventes por um longo tempo.

Há um limite definido para a promoção de um objeto que decide quantos ciclos de coleta de lixo ele pode sobreviver antes de ser movido para a Geração Antiga.

Quando objetos são coletados da Geração Antiga, chamamos de evento maior de coleta de lixo.

Você pode usar as flags -Xms e -Xmx para determinar o tamanho inicial e máximo da memória heap.

Já que o Java utiliza coleta de lixo geracional, quanto mais eventos de coleta um objeto sobrevive, mais ele é promovido na heap. Ele começa na Geração Jovem e eventualmente termina na Tenured Generation se conseguir sobreviver por tempo suficiente.

Considere o seguinte exemplo para entender a promoção de objetos entre espaços e gerações:

Quando um objeto é criado, ele primeiro fica alocado no Espaço Éden da Geração Jovem. Quando um evento menor de coleta de lixo ocorre, os objetos vivos são promovidos ao FromSpace. Quando um novo evento menor ocorre, tanto os objetos vivos do Éden e do FromSpace são movidos para o ToSpace.

Este ciclo continua por um número específico de vezes. Se o objeto continuar sendo referenciado até esse ponto, o próximo ciclo de coleta de  lixo vai movê-lo para o espaço da Geração Antiga.

Geração permanente

Metadados de classes e métodos são alocados na Geração Permanente (Permanent Generation). Ela é utilizada pela JVM durante o tempo de execução com base nas classes em uso pela aplicação. Classes que não estão mais em uso nesta Geração podem ser coletadas pelo Garbage Collector.

Você pode usar as flags -XX:PermGen e -XX:MaxPermGen para determinar o tamanho inicial e máximo da Permanent Generation.

MetaSpace

A partir do Java 8, o espaço de memória MetaSpace substituiu o espaço PermGen. A implementação difere da PermGen, e este espaço da Heap agora é redimensionado automaticamente.

Isso evita o problema de aplicações ficarem sem memória devido ao tamanho limite do espaço PermGen da memória Heap. A memória MetaSpace pode ser coletada e as classes que não estão mais em uso podem ser automaticamente coletadas quando o MetaSpace alcança seu tamanho limite.

Tipos de Garbage Collector na Máquina Virtual do Java

A coleta de lixo faz com que o Java seja uma linguagem eficiente no quesito de uso de memória porque remove os objetos sem referência da memória heap e libera espaço para novos objetos.

A Máquina Virtual do Java tem oito tipos de coletores de lixo. Vamos conhecer cada um deles com mais detalhe.

GC serial

Esta é a implementação mais simples do Garbage Collector e foi feita para aplicações pequenas que estão sendo executadas em ambientes single-threaded. Todos os eventos de coleta de lixo são conduzidos em série em uma thread. A compactação da memória é executada após cada coleta.

Quando a aplicação é executada, ocorre um evento "stop the world" (pare o mundo) onde toda a aplicação é pausada. Já que a aplicação inteira é congelada durante a coleta de lixo, o GC serial não é recomendado em aplicações de larga escala, onde a latência baixa é uma necessidade.

O argumento da JVM para utilizar o Garbage Collector serial é -XX:+UeSerialGC.

GC paralelo

O coletor paralelo é feito para aplicações com conjuntos de dados de médio a largo porte que rodam em multiprocessadores ou hardware multi-threaded. Essa é a implementação padrão do Garbage Collector da JVM e também é conhecida como Throughput Collector.

Múltiplas threads são utilizadas para um evento menor de coleta de lixo na Geração Jovem. Uma única thread é utilizada para eventos maiores de coleta na Geração Velha.

Executar o GC paralelo também ocasiona o evento "stop the world" e a aplicação é pausada. Já que esta implementação é mais apropriada em um ambiente multi-threaded, ela pode ser usada quando muitas atividades são feitas e pausas longas são aceitáveis, como, por exemplo, executar uma tarefa em lote.

O argumento na JVM para executar o GC paralelo é -XX:+UseParallelGC.

GC paralelo antigo

Essa é a versão padrão do GC paralelo desde o Java 7u4. É a mesma implementação do GC paralelo, exceto pelo fato de utilizar threads múltiplas tanto para a Geração Jovem quanto para a Velha.

O argumento na JVM para executar o Garbage Collector paralelo antigo é -XX:+UseParallelOldGC.

GC CMS (Concurrent Mark Sweep)

Essa implementação também é conhecida como o coletor de pausa baixa simultânea. Múltiplas threads são usadas como coletas de lixo menores usando o mesmo algoritmo do paralelo. Coletas de lixo maiores são multi-threaded, como no GC paralelo antigo, mas o CSM roda de forma simultânea aos processos da aplicação para minimizar os eventos "stop the world".

Por causa disso, o coletor CSM usa mais CPU do que as outras implementações de GC. Se você pode alocar mais CPU em prol de melhor desempenho, o CMS é uma escolha melhor que o paralelo. Não há compactação nesta implementação.

O argumento na JVM para usar o Garbage Collector de Concurrent Mark Sweep (em português, algo como "varredura de marca concorrente") é -XX:+UseConcMarkSweepGC.

GC G1 (Garbage First)

O G1GC tinha a intenção de substituir o CMS e foi criado para aplicações multi-threaded que possuem um tamanho grande de memória heap disponível (acima de 4GB). É implementado de modo paralelo e simultânea, como o CMS, mas funciona de maneira um pouco diferente debaixo dos panos em comparação com os garbage collectors anteriores.

Apesar do G1 também ser geracional, ele não separa espaços para as gerações Jovem e Velha. Na verdade, cada geração é um conjunto de espaços, o que permite alterar o tamanho da Geração Jovem de modo flexível.

Ele particiona a heap em um conjunto de espaços de tamanhos iguais (1MB a 32MB - dependendo do tamanho da heap) e utiliza múltiplas threads para as escanear. Uma região pode ser Velha ou Jovem em qualquer período de tempo durante a execução do programa.

Após o período de marcação ser completo, o G1 sabe quais espaços contêm mais objetos que precisam ser coletados. Se o usuário está interessado em tempos de pausa mínimos, o G1 pode escolher evacuar apenas alguns espaços. Se o usuário não se preocupa com isso ou definiu um tempo de pausa grande, o G1 pode escolher incluir mais espaços.

Já que o G1CC identifica os espaços com a maior quantidade de lixo e realiza a coleta naqueles espaços primeiro, ele é chamado de Garbage First (lixo primeiro).

Além dos espaços de memória Eden, Sobreviventes e Velho, existem mais dois tipos de espaços presentes no G1CC:

• Humongous (Enorme) – usado para objetos grandes (maiores que 50% do tamanho da heap)
• Available (Disponíveis) – usado para espaços não utilizados ou não alocados.

O argumento na JVM para usar o Garbage Collector G1 é -XX:+UseG1GC .

Garbage Collector Epsilon

O Epsilon é um coletor de lixo "do-nothing" (que "não faz nada") que foi lançado como parte da JDK 11. Ele gerencia a alocação de memória, mas não implementa nenhum mecanismo de aproveitamento de memória. Uma vez que a memória heap disponível está cheia, a JVM para de funcionar.

Ele pode ser usado para aplicações que são sensíveis a latências extremas, onde os desenvolvedores sabem o footprint exato da memória da aplicação, ou até mesmo possuem aplicações que são (quase) garbage-free (livres de lixo). A utilização do GC Epsilon em qualquer outro cenário é desencorajado.

O argumento na JVM para utilizar o Garbage Collector Epsilon é -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC.

Shenandoah

O Shenandoah é um GC novo que foi lançado como parte do JDK 12. A sua vantagem principal sobre o Garbage Collector G1 é que ele realiza mais ciclos de coleta de lixo de maneira simultânea às threads da aplicação. O G1 pode evacuar seus espaços na heap apenas quando a aplicação é pausada, enquanto o Shenandoah pode realocar objetos simultaneamente com a aplicação.

Shenandoah pode compactar objetos vivos, coletar o lixo e mandar RAM de volta ao sistema operacional quase imediatamente após detectar memória livre. Já que tudo isso ocorre simultaneamente enquanto a aplicação roda, o Shenandoah é mais intensivo no quesito do uso de CPU.

O argumento na JVM para utilizar o Garbage Collector Shenandoah é -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC.

ZGC

O ZGC é outro Garbage Collector que foi lançado como parte da JDK 11 e foi melhorado na JDK 12. Ele foi criado para aplicações que requerem baixa latência (pausas de menos de 10ms) e/ou que utilizam um grande espaço da memória heap (multi-terabytes).

Os principais objetivos do ZGC são a baixa latência, escalabilidade e facilidade de uso. Para alcançar isso, o ZGC permite que uma aplicação em Java continue rodando enquanto ele executa todas as operações de Garbage Collection. Por padrão, o ZGC libera a memória não utilizada e a retorna ao sistema operacional.

Logo, o ZGC traz uma melhora significativa sobre outros Garbage Collectors tradicionais ao prover tempos de pausa extremamente baixos (tipicamente dentro de 2ms).

O argumento na JVM para utilizar o Garbage Collector Shenandoah é -XX:+UnlockExperimentalVMOptions -XX:+UseZGC.

Observação: tanto o Shanandoah quanto o ZGC estão sob planos de passarem a ser features de produção e serem removidos do estágio de experimentação na JDK 15.

Como escolher o Garbage Collector certo?

Se a sua aplicação não tem tempos de pausa estritos, você deve somente rodar a sua aplicação e deixar a JVM escolher o coletor certo para você.

Na maior parte do tempo, as configurações padrão devem funcionar bem. Se necessário, você pode ajustar o tamanho da heap para melhorar o desempenho. Se o desempenho ainda não alcançar suas expectativas, você pode alterar o coletor de lixo padrão de acordo com as necessidades do seu projeto:

• Serial – se a aplicação tem um conjunto de dados pequeno (aproximadamente 100MB) e/ou vai rodar em um único processador sem ter requisitos de tempo de pausa.
• Paralelo – se o melhor desempenho da aplicação for a prioridade e não houver requisitos para tempos de pausa ou pausas de um segundo ou mais serão aceitáveis.
• CMS/G1 – se o tempo de resposta é mais importante que a taxa de processamento e as pausas de coleta de lixo devem ser mantidas abaixo de aproximadamente um segundo.
• ZGC – se o tempo de resposta for a prioridade maior, e/ou você está usando grande parte da heap.

Vantagens do Garbage Collection

Existem múltiplos benefícios da coleta de lixo em Java.

Primeiramente, ela deixa o seu código mais simples. Você não precisa se preocupar com a alocação correta de memória e ciclos de liberação. Você para de usar um objeto no seu código e a memória que ele utiliza vai ser automaticamente liberada em algum momento.

Programadores que trabalham em linguagens sem Garbage Collection (como C e C++) devem implementar gerenciamento de memória manual em seus códigos.

Este processo também faz com que o Java seja eficiente em termos de memória, pois o coletor de lixo remove os objetos não referenciados da memória heap. Isso libera espaço na heap para acomodar novos objetos.

Enquanto alguns programadores argumentam em favor do gerenciamento de memória manual ao invés de Garbage Collection, o GC é agora um componente padrão em diversas linguagens de programação populares.

Para cenários onde o Garbage Collector impacta negativamente o desempenho, o Java oferece diversas opções para melhorar sua eficiência.

Melhores práticas de Garbage Collection

Evite disparos manuais

Além dos mecanismos básicos de coleta de lixo, um dos pontos mais importantes para entender a respeito de Garbage Collection no Java é que ele não é determinístico. Isso significa que não tem como prever quando a coleta de lixo vai ocorrer durante o tempo de execução.

É possível incluir uma sugestão à JVM no seu código para que ela inicie o coletor de lixo com os métodos System.gc() ou Runtime.gc(), mas isso não dá garantia de que o coletor realmente vai ser executado.

Utilize ferramentas de análise

Se você não tem memória suficiente para rodar sua aplicação, você vai lidar com problemas de lentidão, um longo período de coleta de lixo, eventos "stop the world" e, por fim, erros do tipo out of memory. Isso pode indicar que o tamanho da sua heap é muito pequeno, mas também que você pode ter um vazamento de memória na sua aplicação.

Você pode ter o auxílio de uma ferramenta de monitoramento como o jstat ou Java Flight Recorder para analisar se o uso da memória heap cresce indefinidamente, o que pode indicar um bug no seu código.

Configurações padrão são suas amigas

Se você estiver executando uma aplicação Java pequena e independente, você muito provavelmente não precisa alterar as configurações do Garbage Collector. As configurações padrão devem dar conta do trabalho.

Utilize flags na JVM para ajustes

A melhor forma de ajustar a Garbage Collection de acordo com as suas necessidades é utilizando flags na JVM. Flags podem configurar o GC que vai ser utilizado (Serial, G1 ou outros), o tamanho inicial e máximo da memória heap, o tamanho dos espaços da heap (Geração Jovem, Velha) e muito mais.

Escolha o coletor apropriado

A natureza da aplicação que está passando por ajustes é um guia inicial muito eficiente para as configurações do coletor. Por exemplo, o GC paralelo é eficiente, mas vai causar eventos "stop the world" frequentes, fazendo com que ele seja mais apropriado para processamento em back-end, onde as longas pausas para coleta de lixo são aceitáveis.

Por outro lado, o Garbage Collector CMS foi criado para minimizar pausas, sendo ideal para aplicações baseadas na Web, onde a responsividade é importante.

Conclusão

Neste artigo, discutimos Garbage Collection em Java, como funciona e seus diferentes tipos.

Para muitas aplicações simples, Garbage Collection não é algo que um programador Java precise considerar. Contudo, para programadores que querem melhorar suas habilidades em Java, é importante entender como esse processo funciona.

Este conceito também é muito popular em entrevistas técnicas, tanto para cargos de back-end júnior, quanto sênior.

Agradecemos por sua companhia até aqui. Esperamos que tenha gostado do artigo. Você pode se conectar com o autor pelo LinkedIn, onde ele fala regularmente sobre assuntos como tecnologia e a vida. Dê uma olhada também em outros artigos do autor (em inglês) e no canal do autor no YouTube. Boa leitura. 🙂️