Jhénifer Matos de Mendonça Pereira RGA:2021.1906.

038-7

Lista 4

1- Cada thread precisa de um conjunto próprio de registradores lógicos para que possam ser
executadas simultaneamente em uma única CPU, sem que as informações de uma thread interfiram na
execução de outra.

2- O servidor monothread pode tratar 20 requisições/segundo e o servidor multithread pode tratar mais
de 20 requisições/segundo, dependendo do número de threads utilizadas.

3- Sim, é possível impor uma ordem estrita de execução das threads utilizando o método join() da
classe Thread.

4-Falso. Em uma máquina com uma única CPU, as threads não podem executar literalmente mais de
uma tarefa simultaneamente, pois apenas uma instrução pode ser executada por vez. As threads são
alternadas rapidamente, dando a impressão de que estão sendo executadas simultaneamente.

5-Não, nem todos os programas podem ser reescritos para serem multithread, pois alguns programas
possuem dependências entre as suas instruções, o que limita a capacidade de paralelização.

6- Sim, o uso de threads pode trazer melhoria de desempenho em relação a uma versão puramente
sequencial, principalmente em máquinas multiprocessadas, pois permite que os cálculos sejam
executados em paralelo. No entanto, em máquinas monoprocessadas, o ganho de desempenho pode
ser limitado.

7- Uma thread compartilha informações como o espaço de endereçamento do processo que a criou,
mas cada thread possui seu próprio contexto de execução, como o conjunto de registradores, o
contador de programa e a pilha de execução.

8- A troca de contexto de threads é mais rápida que a troca de contexto de processos porque as threads
compartilham o mesmo espaço de endereçamento e contexto de execução, o que torna a troca de
contexto mais simples e rápida.

9- O uso de processos é mais apropriado do que o uso de threads em situações em que é necessário
isolar recursos entre os processos, como em sistemas de segurança ou quando os processos precisam
ser executados em diferentes ambientes. Além disso, os processos são mais robustos em relação a
falhas, pois não compartilham o mesmo espaço de endereçamento.

10- Sim, uma solução multithread usando múltiplas threads em nível de usuário pode conseguir
desempenho melhor em um sistema de multiprocessadores do que em um sistema de único
processador, pois em um sistema multiprocessado, as threads podem ser distribuídas entre os
processadores disponíveis, permitindo a execução simultânea em vários núcleos de processamento.
Isso pode levar a um aumento significativo de desempenho em comparação com um sistema de único
processador, onde as threads são executadas em um único núcleo de processamento.

11- a) O newFixedThreadPool(int) cria uma piscina de threads com um número fixo de threads
pré-criadas. Quando uma tarefa é submetida à piscina e todas as threads estiverem ocupadas, ela é
colocada em uma fila até que uma thread esteja disponível. Esse tipo de arquitetura é adequado para
situações em que há um número previsível de tarefas a serem executadas e se deseja limitar a
quantidade de threads criadas.

b) O newCachedThreadPool() cria uma piscina de threads com um número variável de threads,

criando novas threads conforme necessário e reutilizando threads existentes quando disponíveis. Isso
é adequado para situações em que o número de tarefas a serem executadas é desconhecido e pode
variar muito. No entanto, como não há limitação para o número de threads que podem ser criados,
pode haver problemas de desempenho em sistemas com recursos limitados.

c) O newSingleThreadExecutor() cria uma piscina de threads com apenas uma thread. Isso é adequado
para situações em que as tarefas precisam ser executadas sequencialmente e em ordem, e garante que
apenas uma tarefa seja executada de cada vez.

12-

Java
import java.util.Scanner;
import java.util.concurrent.atomic.AtomicBoolean;

public class GeradorPrimos implements Runnable {

private final int numeroLimite;
private final AtomicBoolean[] primos;

public GeradorPrimos(int numeroLimite, AtomicBoolean[]

primos) {
this.numeroLimite = numeroLimite;
this.primos = primos;}

@Override
public void run() {
for (int i = 2; i <= numeroLimite; i++) {
if (isPrimo(i)) {
primos[i].set(true);}}}

private boolean isPrimo(int numero) {

if (numero <= 1) {
return false; }

for (int i = 2; i <= Math.sqrt(numero); i++) {

if (numero % i == 0) {
return false; }}
 return true;}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print("Digite um número: ");

int numeroLimite = scanner.nextInt();

AtomicBoolean[] primos = new

AtomicBoolean[numeroLimite + 1];

for (int i = 0; i < primos.length; i++) {

primos[i] = new AtomicBoolean(false);}

Thread thread = new Thread(new

GeradorPrimos(numeroLimite, primos));
thread.start();

try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();}

System.out.println("Números primos menores ou iguais a

" + numeroLimite + ":");

for (int i = 2; i <= numeroLimite; i++) {

if (primos[i].get()) {
System.out.print(i + " ");}}}}

13-

Java
import java.util.Scanner;

public class FibonacciThread extends Thread {

private int n;
private int[] sequence;
 public FibonacciThread(int n, int[] sequence) {
this.n = n;
this.sequence = sequence;
}

public void run() {

for (int i = 0; i < n; i++) {
if (i == 0) {
sequence[i] = 0;
} else if (i == 1) {
sequence[i] = 1;
} else {
sequence[i] = sequence[i-1] + sequence[i-2];
}}}

public static void main(String[] args) throws

InterruptedException {
Scanner sc = new Scanner(System.in);
System.out.print("Digite a quantidade de números de
Fibonacci que deseja gerar: ");
int n = sc.nextInt();

int[] sequence = new int[n];

FibonacciThread thread = new FibonacciThread(n,

sequence);
thread.start();
thread.join();

System.out.print("Sequência de Fibonacci gerada: ");

for (int i = 0; i < n; i++) {
System.out.print(sequence[i] + " ");}}}
14-

Java
public class MatrixMultiplication {
private static final int THREAD_POOL_SIZE = 4;

private static int[][] matrixA;

private static int[][] matrixB;
private static int[][] matrixC;

public static void main(String[] args) {

int M = 3;
int K = 2;
int N = 3;

matrixA = new int[][]{{1, 2}, {3, 4}, {5, 6}};

matrixB = new int[][]{{7, 8, 9}, {10, 11, 12}};

matrixC = new int[M][N];

ExecutorService executor =
Executors.newFixedThreadPool(THREAD_POOL_SIZE);

for (int i = 0; i < M; i++) {

for (int j = 0; j < N; j++) {
Runnable worker = new MatrixWorker(i, j, K);
executor.execute(worker);}}
executor.shutdown();

while (!executor.isTerminated()) {
// Espera até que todos os trabalhadores terminem}

// Exibe a matriz produto

for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
System.out.print(matrixC[i][j] + " ");}
System.out.println(); }}

private static class MatrixWorker implements Runnable {

private final int row;
private final int col;
private final int K;

public MatrixWorker(int row, int col, int K) {

this.row = row;
this.col = col;
this.K = K;}

@Override
public void run() {
int sum = 0;
for (int k = 0; k < K; k++) {
sum += matrixA[row][k] * matrixB[k][col]; }
matrixC[row][col] = sum;}}}