CENTRO FEDERAL DE EDUCAO TECNOLGICA DE MINAS GERAIS

CAMPUS VII - UNIDADE TIMTEO - Engenharia da Computao

Sistemas Distribudos
Mike Paiva, Paula Peanha, Robson Curvelo

Trabalho Prtico:
Soluo Concorrente para Multiplicao de Matrizes

Introduo

Este trabalho trata-se do desenvolvimento de uma aplicao de Soluo Concorrente para Multiplicao
de Matrizes em linguagem de programao Java.
O gerenciamento de transaes concorrentes depende de vrias operaes realizadas no servidor que
garante que a concorrncia entre os clientes para que o acesso ao servidor seja livre de falhas.
As transaes devem ser realizadas ou bloqueadas, seus valores devem ser consistentes do inicio ao fim
da transao, as transaes concorrentes no podem interferir uma nas outras, este um dos principais
comportamentos desenvolvidos nesta soluo de comunicao e os arquivos transferidos devem ser
salvos de forma consistente evitando erros no armazenamento de dados.
Em transao concorrente, todos seus protocolos so baseados em critrio da equivalncia serial garantindo que os provveis conflitos que possam ser gerados sejam solucionados por meio de Travas (locks)
e Bloqueios, Concorrncia Otimista e Ordenao da indicao de Tempo que possibilitam solues de
falhas na comunicao concorrente como: acesso a um mesmo objeto ao mesmo tempo por vrios
clientes, falta de consistncia e acesso de transaes de forma desordenada [1].
No acesso concorrente, o qual utilizado em um servio cliente/servidor, falhas ou erros de acesso
podem ser gerados devido a esse tipo de acesso aos dados. Desta forma, o conceito de multi-threads
pode ser utilizado possibilitando a concorrncia de acesso a um nico objeto de forma ordenada e
consistente.
Neste trabalho, desenvolvida uma aplicao de concorrncia para multiplicao de matrizes que
consiste basicamente em obter o resultado de cada elemento da matriz resultante em processos de
threads diferentes, que no final sero juntados.

Sistemas Distribudos
Mike Paiva, Paula Peanha, Robson Curvelo

Sem a aplicao de soluo concorrente os dados poderiam ser identificados de forma desordenada, o
que poderia gerar valores errados sobre a multiplicao das matrizes. Por exemplo, se um dos dados
referente a uma matriz, acessasse o objeto MultiplicacaoMatriz de forma desordenada, ele poderia
ser multiplicado por um outro dado que poderia no ser o correto. Ou seja, os dados poderiam ser
multiplicados de forma desordenada fornecendo um resultado equivocado.

Metodologia

O trabalho consiste em desenvolver uma aplicao que faa multiplicao de matrizes operando em
concorrncia. Como base, foi consultado o livro Sistemas Operacionais com Java, de Silberschatz, Galvin
e Gagne [4].
O projeto foi implementado em uma mquina que possui o sistema operacional Windows 10, com
processador Intel Core i5-3210M, o qual contm dois ncleos e quatro threads [2], utilizando o software
Netbeans IDE 8.0 e a linguagem de programao Java.
Primeiramente, foi criada uma classe, Threads.java, que herda caractersticas da interface Runnable.
Essa interface utilizada por classes que pretendem executar suas instncias por meio de threads [3].
A classe Threads.java, composta pelos seguintes atributos:
linha - inteiro que corresponde ao ndice da linha da matriz produto que se deseja calcular;
matriz A - corresponde ao primeiro fator da multiplicao das matrizes;
matriz B - corresponde ao segundo fator da multiplicao das matrizes;
matriz C - corresponde a matriz resultante;
K - corresponde ao nmero de colunas da matriz A e linhas da matriz B.
Alm dos atributos citados, a classe tambm possui um construtor que recebe por parmetro linha,
coluna, matriz A, matriz B e matriz C, e a funo run(), que calcula todos os elementos de uma linha da
matriz resultante.
Em seguida, foi implementada a classe principal, MultiplicacaoMatriz.java, que constituda pelos
seguintes atributos:

Sistemas Distribudos
Mike Paiva, Paula Peanha, Robson Curvelo

M - valor inteiro esttico que corresponde ao nmero de linhas das matrizes A e C;

N - valor inteiro esttico que corresponde ao nmero de colunas das matrizes B e C;
K - valor inteiro esttico que corresponde ao nmero de colunas da matriz A e linhas da matriz B;
numThread - valor inteiro esttico que corresponde ao nmero de threads = M.
Adicionalmente aos atributos, a classe MultiplicacaoMatriz.java, contm a funo main(), onde foram
declaradas as matrizes A e B para multiplicao, e reservado um espao na memria para a matriz
resultante C.
Para atender o objetivo do trabalho, foi criado um vetor thread do tipo Thread. O papel deste vetor era
calcular de forma concorrente cada linha da matriz C. Os resultados dos clculos das threads foram
reunidos atravs da funo join().
Por fim, com a utilizao de dois laos de repetio, for (um dentro do outro), a matriz produto
percorrida e impressa.

Resultados

Para multiplicao de matrizes, deve-se alterar os valores de A e B, levando em considerao que o

nmero de colunas de A deve ser igual ao nmero de linhas de B.
Deve-se tambm alterar os valores de M, N, K e numThread, dentro de MultiplicacaoMatriz.java, e o
valor de K, dentro de Threads.java.
Aps editar as variveis, basta executar a classe principal.

Figura 1: Output da aplicao

As matrizes utilizadas como exemplo para a execuo foram: A = (1 4; 2 5; 3 6); e B = (8 7 6; 5 4 3);, e o
resultado da multiplicao, A*B, impresso na tela apresentado na Figura 1.

Sistemas Distribudos
Mike Paiva, Paula Peanha, Robson Curvelo

Anlise

A execuo de aplicaes por meio de threads objetiva minimizar o tempo total e a sobrecarga de
memria de processamento consumidos pelo programa. As threads realizam tarefas independentes
de forma paralela, o que gasta menos tempo em comparao ao que seria utilizado para realizar as
mesmas tarefas de forma sequencial.
De forma a analisar a questo do tempo, foram realizados testes com contadores de tempo antes e
depois do clculo da matriz resultante. Alm da execuo por threads, foi implementado tambm um
clculo de forma sequencial. O qual se encontra a seguir.
1

l o n g s t a r t T e m p o = System . c u r r e n t T i m e M i l l i s ( ) ;

2
3

for ( int

4
5
6
7
8
9
10
11

i = 0 ; i < M ; i + + ) { // P e r c o r r e a l i n h a
f o r ( i n t j = 0 ; j < N ; j + + ) { // P e r c o r r e a c o l u n a
i n t r e s u l t = 0;
f o r ( i n t x = 0; x < K ; x + + ) {
r e s u l t += A [ i ] [ x ] * B [ x ] [ j ] ;
}
C[ i ][ j ] = result ;
}

12
13

l o n g stopTempo = System . c u r r e n t T i m e M i l l i s ( ) ;

14
15

System . out . p r i n t l n ( " Durao : " + ( stopTempo s t a r t T e m p o ) ) ;

Multiplica.java
Para alguns experimentos, foram utilizadas matrizes de tamanhos de at 5 por 5. O tempo de durao
das execues foi muito pequeno, na maior parte dos testes se igualava a zero.
Outro teste foi conduzido com matrizes de tamanhos 1000 por 1000, e assim, foram criadas 1000
threads, uma por linha. Nesse caso, os tempos de execuo das threads, Figura 2, foi bem reduzido se
comparado ao tempo de execuo da multiplicao das matrizes de forma sequencial, Figura 3.

Sistemas Distribudos
Mike Paiva, Paula Peanha, Robson Curvelo

Figura 2: Output da aplicao utilizando Threads

Figura 3: Output da aplicao com clculo da multiplicao de forma sequencial

Concluso

A partir dos resultados e anlises observados neste trabalho, conclui-se que uma soluo concorrente
para multiplicao de matrizes pode complementar o contedo sobre transaes e concorrncias
apresentados em sala de aula.
A utilizao de juno de mltiplas threads permitiu que este trabalho alcanasse o seu objetivo terico
e prtico sobre o paralelismo de processos. Este conceito pode ser aplicado em diversas servios
existentes, possibilitando a otimizao do desempenho dos mesmos.

Referncias
[1] George Coulouris, Jean Dollimore, Tim Kindberg, and Gordon Blair. Sistemas Distribudos: Conceitos
e Projeto. Bookman Editora, 2013.
[2] Intel. Intel core i5-3210m processor. 2013. URL http://goo.gl/DhEJLL. Acessado em:
19-11-15.

Sistemas Distribudos
Mike Paiva, Paula Peanha, Robson Curvelo

[3] Oracle. Interface runnable. 2014. URL http://goo.gl/GDHNnC. Acessado em: 19-11-15.
[4] GALVIN SILBERSCHATZ and GAGNE. Sistemas Operacionais com Java. Editora Elsevier, 7 edition,
2008.

6
1
2
3
4
5
6

Anexos

/*
* C l a s s e T h r e a d s p a r a m u l t i p l i c a o de m a t r i z e s
*
* D e s e n v o l v i d o por : Mike , P a u l a e Robson
*/
package m u l t i p l i c a c a o m a t r i z ;

7
8

p u b l i c c l a s s Threads implements Runnable {

private
private
private
private

10
11
12
13

int
int
int
int

linha , coluna ;
[][] A;
[][] B;
[][] C;

14

private static
matriz B

15

i n t K = 2 ; // Nmero de c o l u n a s da m a t r i z A e l i n h a s da

16

// C o n s t r u t o r da c l a s s e T h r e a d s
public Threads ( i n t linha , i n t [ ] [ ] A ,
this . linha = linha ;
this .A = A;
this .B = B;
this .C = C;
}

17
18
19
20
21
22
23

int [][] B,

int [][] C) {

24

// F u n o u t i l i z a d a p a r a
@Override
p u b l i c void run ( ) {
f o r ( i n t c o l = 0; c o l
f o r ( i n t j = 0; j
C[ linha ][ col ]
}
}
}

25
26
27
28
29
30
31
32
33
34
35

c a l c u l a r o s e l e m e n t o s da l i n h a de C
< B [0]. length ; col ++) {
< K; j ++) {
+= A [ l i n h a ] [ j ] * B [ j ] [ c o l ] ;

Sistemas Distribudos
Mike Paiva, Paula Peanha, Robson Curvelo

Threads.java

1
2
3
4
5
6

/*
* T r a b a l h o P r t i c o 4 M u l t i p l i c a o de M a t r i z e s
*
* D e s e n v o l v i d o por : Mike , P a u l a e Robson
*/
package m u l t i p l i c a c a o m a t r i z ;

7
8
9
10

import s t a t i c j a v a . time . Clock . system ;

import java . u t i l . logging . Level ;
import java . u t i l . logging . Logger ;

11
12

public class

MultiplicacaoMatriz {

13
14
15

16
17

private s t a t i c int M = 3;
// Nmero de l i n h a s d a s
private s t a t i c int K = 2;
// Nmero de c o l u n a s da
l i n h a s da m a t r i z B
private s t a t i c int N = 3;
// Nmero de c o l u n a s d a s
f i n a l s t a t i c i n t n u m T h r e a d = 3 ; // Nmero de t h r e a d s
linhas M

matrizes A e C
m a t r i z A e de
matrizes B e C
= n m ero de

18
19
20

p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
// TODO c o d e a p p l i c a t i o n l o g i c h e r e

21
22
23
24

int A [][] =
int B [][] =
int C [][] =
memria

{{1 ,4} ,{2 ,5} ,{3 ,6}};

{{8 ,7 ,6} ,{5 ,4 ,3}} ;
new i n t [ M ] [ N ] ;
para a matriz produto

// D e c l a r a o da m a t r i z A
// D e c l a r a o da m a t r i z B
// A l o c a o de e s p a o na

25
26
27
28
29
30
31
32
33
34

/*
// G e r a m a t r i z e s MxN
f o r ( i n t i = 0; i <
f o r ( i n t j = 0;
A[ i ][ j ] = i
B[ i ][ j ] = i
}
}
*/

M;
j
+
*

para m u l t i p l i c a o M deve s e r i g u a l a N
i + + ) { // P e r c o r r e a l i n h a
< N ; j + + ) { // P e r c o r r e a c o l u n a
j;
j;

35
36

37

T h r e a d [ ] t h r e a d = new T h r e a d [ n u m T h r e a d ] ;
// U t i l i z a o da
b i b l i o t e c a Thread
i n t nT = 0 ;
// V a r i v e l a u x i l i a r p a r a p e r c o r r e r a s t h r e a d s

38
39
40

l o n g s t a r t T e m p o = System . c u r r e n t T i m e M i l l i s ( ) ;

Sistemas Distribudos
Mike Paiva, Paula Peanha, Robson Curvelo

f o r ( i n t i = 0 ; i < M ; i + + ) { // P e r c o r r e a l i n h a
t h r e a d [ nT ] = new T h r e a d ( new T h r e a d s ( i , A , B , C ) ) ;
// C r i a
uma i n s t n c i a de c a d a t h r e a d u t i l i z a n d o a c l a s s e c r i a d a
Threads
t h r e a d [ nT ] . s t a r t ( ) ;
// I n i c i a a e x e c u o de c a d a i n s t n c i a
de t h r e a d
nT + + ;
// I n c r e m e n t a o n d i c e d a s t h r e a d s
}

41
42

43

44
45
46

f o r ( i n t i = 0; i < numThread ; i + + ) {
try {
t h r e a d [ i ] . j o i n ( ) ; // J u n t a o r e s u l t a d o o b t i d o p o r c a d a
thread
} c a t c h ( I n t e r r u p t e d E x c e p t i o n ex ) {
L o g g e r . g e t L o g g e r ( M u l t i p l i c a c a o M a t r i z . c l a s s . getName ( ) ) . l o g (
L e v e l . SEVERE , n u l l , e x ) ;
}
}

47
48
49

50
51

52
53
54
55

/*

f o r ( i n t i = 0 ; i < M ; i + + ) { // P e r c o r r e a l i n h a
f o r ( i n t j = 0 ; j < N ; j + + ) { // P e r c o r r e a c o l u n a
i n t r e s u l t = 0;
f o r ( i n t x = 0; x < K ; x + + ) {
r e s u l t += A [ i ] [ x ] * B [ x ] [ j ] ;
}
C[ i ][ j ] = result ;
}
}

56
57
58
59
60
61
62
63
64
65

*/

l o n g stopTempo = System . c u r r e n t T i m e M i l l i s ( ) ;

66
67

// I m p r i m e a m a t r i z r e s u l t a n t e
f o r ( i n t i = 0 ; i < M ; i + + ) { // P e r c o r r e a l i n h a
f o r ( i n t j = 0 ; j < N ; j + + ) { // P e r c o r r e a c o l u n a
S y s t e m . o u t . p r i n t ( C [ i ] [ j ] + " " ) ; // A c e s s a c a d a i t e m da
matriz
}
System . out . p r i n t l n ( ) ;
}

68
69
70
71

72
73
74
75
76
77
78

System . out . p r i n t l n ( " \ nDurao : " + ( stopTempo s t a r t T e m p o ) ) ;

MultiplicacaoMatriz.java