Java: Exemplo de Produtor Consumidor - Lidar com Leitura/Gravação Simultânea

Publicados: 2019-02-17

Exemplo de Produtor Consumidor - Lidar com Leitura:Gravação Simultânea

O producer-consumer problem (também conhecido como bounded-buffer problem ) é um exemplo clássico de Java de um problema de sincronização de vários processos.

O problema descreve dois processos, the producer e the consumer , que compartilham um buffer comum de tamanho fixo usado como fila. O trabalho do produtor é gerar um dado, colocá-lo no buffer e começar de novo.

Ao mesmo tempo, o consumidor está consumindo os dados (ou seja, removendo-os do buffer) um por vez. O problema é garantir que o produtor não tentará adicionar dados ao buffer se estiver cheio e que o consumidor não tentará remover dados de um buffer vazio.

Abaixo o programa Java simples criará este problema:

Exemplos Java – Problema do Consumidor do Produtor

CrunchifyProducerConsumer.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package com . crunchify . tutorials ;
 
import java . util . Vector ;
import java . util . Iterator ;
 
/**
* @author Crunchify
*/
 
public class CrunchifyProducerConsumer {
     private static Vector <Object> data = new Vector <Object> ( ) ;
 
     public static void main ( String [ ] args ) {
         new Producer ( ) . start ( ) ;
         new Consumer ( ) . start ( ) ;
     }
 
     public static class Consumer extends Thread {
         Consumer ( ) {
             super ( "Consumer" ) ;
         }
 
         @Override
         public void run ( ) {
             for ( ; ; ) {
                 try {
                     Thread . sleep ( 1 ) ;
                 } catch ( Exception e ) {
                     e . printStackTrace ( ) ;
                 }
                 @SuppressWarnings ( "rawtypes" )
                 Iterator it = data . iterator ( ) ;
                 while ( it . hasNext ( ) )
                     it . next ( ) ;
             }
         }
     }
 
     public static class Producer extends Thread {
         Producer ( ) {
             super ( "Producer" ) ;
         }
 
         @Override
         public void run ( ) {
             for ( ; ; ) {
                 try {
                     Thread . sleep ( 1 ) ;
                 } catch ( Exception e ) {
                     e . printStackTrace ( ) ;
                 }
                 data . add ( new Object ( ) ) ;
                 if ( data . size ( ) > 1000 )
                     data . remove ( data . size ( ) - 1 ) ;
             }
         }
     }
}

Questão:

ConcurrentModificationException
1
2
3
4
Exception in thread "Consumer" java . util . ConcurrentModificationException
     at java . util . ArrayList $ Itr . checkForComodification ( ArrayList . java : 819 )
     at java . util . ArrayList $ Itr . next ( ArrayList . java : 791 )
     at com . crunchify . tutorials . CrunchifyProducerConsumer $ Consumer . run ( CrunchifyProducerConsumer . java : 36 )

Resolução:

Adicione a palavra-chave synchronized para bloquear os data enquanto os estamos usando.

Melhor programa Java:

CrunchifyProducerConsumer.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package crunchify . com . tutorials ;
 
import java . util . Iterator ;
import java . util . Vector ;
 
/**
* @author Crunchify.com
* Producer Consumer Example in Java
*/
 
public class CrunchifyProducerConsumer {
private static Vector <Object> data = new Vector <Object> ( ) ;
 
public static void main ( String [ ] args ) {
new Producer ( ) . start ( ) ;
new Consumer ( ) . start ( ) ;
}
 
public static class Consumer extends Thread {
Consumer ( ) {
super ( "Consumer" ) ;
}
 
@SuppressWarnings ( "rawtypes" )
@Override
public void run ( ) {
for ( ; ; ) {
try {
Thread . sleep ( 1000 ) ;
System . out . println ( "Object Consumed ################" ) ;
} catch ( Exception e ) {
e . printStackTrace ( ) ;
}
 
synchronized ( data ) {
Iterator it = data . iterator ( ) ;
while ( it . hasNext ( ) )
it . next ( ) ;
}
}
}
}
 
public static class Producer extends Thread {
Producer ( ) {
super ( "Producer" ) ;
}
 
@Override
public void run ( ) {
for ( ; ; ) {
try {
Thread . sleep ( 1000 ) ;
System . out . println ( "Object Produced ~~~~~~~~~~~~~~~" ) ;
} catch ( Exception e ) {
e . printStackTrace ( ) ;
}
data . add ( new Object ( ) ) ;
if ( data . size ( ) > 1000 )
data . remove ( data . size ( ) - 1 ) ;
}
}
}
}

Resultado do exemplo do consumidor do produtor Java:

java-produtor-consumidor-tutorial-crunchify