我一直在研究这个问题并且没有找到解决方案,所以如果有人能帮助我,我真的很感激！我可能错过了一些非常明显的东西.这是一个理解同步的赋值,我们在前面的赋值中使用线程来乘以2个矩阵.在前面的赋值中,每个线程乘以一行,因此线程数与行数一样多.
在这个赋值中,我们只应该使用5个线程 – 所有线程都应该以一行/一列开始,一旦线程完成,它应该使用同步选择下一个可用的行/列,所以现在两个线程将最终执行同一栏.
This question帮助我找到了正确的方向,但我必须在实施方面做错了,因为到目前为止我只得到了以下任一项目：
>只执行前5行 – 5个线程执行一次,每个线程计算一行或
>我添加了一个循环(现在在我的代码中注释掉了),所以线程会继续执行,但是当我这样做时,只有第一个线程做任何工作.
这是我的主要和几个辅助方法的类：
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
public class MatrixMult {
public static void main(String[] args){
int[][] matrixA;
int[][] matrixB;
int colA = 0;
int rowA = 0;
int colB = 0;
int rowB = 0;
Scanner userInput = new Scanner( System.in );
System.out.println("Please enter the dimensions of matrix A");
do{
System.out.print("column for matrix A: ");
colA = userInput.nextInt();
System.out.println();
} while(!validDimension(colA));
rowB = colA;
do{
System.out.print("row for matrix A: ");
rowA = userInput.nextInt();
System.out.println();
} while(!validDimension(rowA));
matrixA = new int[rowA][colA];
System.out.println("Please enter the dimensions of matrix B:");
do{
System.out.print("column for matrix B: ");
colB = userInput.nextInt();
System.out.println();
} while(!validDimension(colB));
matrixB = new int[rowB][colB];
fillMatrix(matrixA);
fillMatrix(matrixB);
System.out.println("Would you like to print out matrix A and B? (y/n)");
String userResponse = userInput.next();
if(userResponse.equalsIgnoreCase("y")){
System.out.println("Matrix A:");
printBackMatrix(matrixA);
System.out.println();
System.out.println("Matrix B:");
printBackMatrix(matrixB);
System.out.println();
}
int[][] matrixProduct3 = multMatrixWithThreadsSync(matrixA, matrixB);
String fileName = "C:/matrix.txt";
System.out.println("Matrix product is being written to "+fileName);
try {
printMatrixToFile(matrixProduct3, fileName);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static int[][] multMatrixWithThreadsSync(int[][] matrixA, int[][] matrixB) {
int[][] matrixProduct = new int[matrixA.length][matrixB[0].length];
int[] matrixProductColumn = new int[matrixA.length];
Runnable task = new MultMatrixByRow(matrixA, matrixB, matrixProduct);
for(int i=0; i<5; i++){
Thread worker = new Thread(task);
worker.start();
// System.out.println(worker.getName());
try {
worker.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return matrixProduct;
}
private static void printMatrixToFile(int[][] matrix, String fileName) throws IOException{
PrintWriter userOutput = new PrintWriter(new FileWriter(fileName));
for(int i=0; i<matrix.length; i++){
for(int j=0; j<matrix[0].length; j++){
userOutput.print(matrix[i][j]+" ");
}
userOutput.println();
}
userOutput.close();
}
private static void printBackMatrix(int[][] matrix) {
for(int i=0; i<matrix.length; i++){
for(int j=0; j<matrix[0].length; j++){
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
}
private static void fillMatrix(int[][] matrix) {
Random rand = new Random();
for(int i=0; i<matrix.length; i++){
for(int j=0; j<matrix[0].length; j++){
matrix[i][j] = rand.nextInt(100) + 1;
}
}
}
public static boolean validDimension(int dim){
if (dim <= 0 || dim >1000){
System.err.println("Dimension value entered is not valid");
return false;
}
return true;
}
}
这是我的runnable类：
public class MultMatrixByRow implements Runnable {
private int i;
private int[][] matrixA;
private int[][] matrixB;
private int[][] matrixProduct;
public MultMatrixByRow(int[][] A, int[][] B, int[][] C) {
this.matrixA = A;
this.matrixB = B;
this.matrixProduct = C;
}
@Override
public void run(){
// while(i < matrixProduct.length){
int rowToWork = 0;
synchronized (this){
// System.out.println("i is "+i);
if ( i < matrixProduct.length){
rowToWork = i;
i++;
}
else{
return;
}
}
for(int j = 0; j < matrixB[0].length; j++){
for(int k=0; k < matrixA[0].length; k++){
matrixProduct[rowToWork][j] += matrixA[rowToWork][k]*matrixB[k][j];
}
}
// }
}
}
再次 – 任何帮助真的很感激！非常感谢.
解决方法:
>您没有在资源上进行同步,您需要共享一个锁对象(在静态上下文中或通过构造函数)
>当你甚至不让它们同步工作时,我真的无法弄清楚你的程序中应该同步什么….你启动一个线程并直接等待他停止.
我认为你必须首先启动它们然后在另一个循环中调用每个线程上的连接.
另外,我不太确定你的Threads应该分别运作,我认为它们都可以解决整个产品矩阵.您需要共享一个用于标识已处理的行的变量,您可以访问这些行进行同步.
我可以修复你的代码,但我很感激你自己做这项工作,因为这是一个理解线程并发的任务.
编辑：同步说明：
Synchronized将一个对象作为一个锁,只有一个线程可以为它保存监视器.当拥有锁的监视器时,线程可以处理该块,如果没有,他必须等待获取监视器.在你的情况下,你可以使用私有静态最终Object lock = new Object();作为锁定,您将同步.
编辑2：我完全构建了你的代码
我没有为完成你所有的工作而自豪,但没关系,这就是它.
package anything.synchronize_*_post;
/**
* @date 21.11.2012
* @author Thomas Jahoda
*/
public class ConcurrentMatrixMultiplyingTask implements Runnable {
private int[][] matrixA;
private int[][] matrixB;
private int[][] matrixProduct;
//
private final ConcurrencyContext context;
public ConcurrentMatrixMultiplyingTask(ConcurrencyContext context, int[][] A, int[][] B, int[][] C) {
if (context == null) {
throw new IllegalArgumentException("context can not be null");
}
this.context = context;
this.matrixA = A;
this.matrixB = B;
this.matrixProduct = C;
}
@Override
public void run() {
while (true) {
int row;
synchronized (context) {
if (context.isFullyProcessed()) {
break;
}
row = context.nextRowNum();
}
System.out.println(Thread.currentThread().getName() + " is going to process row " + row);
// i'm not really sure if this matrix algorithm here is right, idk..
for (int j = 0; j < matrixB[0].length; j++) {
for (int k = 0; k < matrixA[0].length; k++) {
matrixProduct[row][j] += matrixA[row][k] * matrixB[k][j];
}
}
}
}
public static class ConcurrencyContext {
private final int rowCount;
private int nextRow = 0;
public ConcurrencyContext(int rowCount) {
this.rowCount = rowCount;
}
public synchronized int nextRowNum() {
if (isFullyProcessed()) {
throw new IllegalStateException("Already fully processed");
}
return nextRow++;
}
public synchronized boolean isFullyProcessed() {
return nextRow == rowCount;
}
}
}
和ProcessingTask
package anything.synchronize_*_post;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Random;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* @date 21.11.2012
* @author Thomas Jahoda
*/
public class MatrixMulti {
public static void main(String[] args) {
int[][] matrixA;
int[][] matrixB;
int colA = 0;
int rowA = 0;
int colB = 0;
int rowB = 0;
Scanner userInput = new Scanner(System.in);
System.out.println("Please enter the dimensions of matrix A");
do {
System.out.print("column for matrix A: ");
colA = userInput.nextInt();
System.out.println();
} while (!validDimension(colA));
rowB = colA;
do {
System.out.print("row for matrix A: ");
rowA = userInput.nextInt();
System.out.println();
} while (!validDimension(rowA));
matrixA = new int[rowA][colA];
System.out.println("Please enter the dimensions of matrix B:");
do {
System.out.print("column for matrix B: ");
colB = userInput.nextInt();
System.out.println();
} while (!validDimension(colB));
matrixB = new int[rowB][colB];
fillMatrix(matrixA);
fillMatrix(matrixB);
System.out.println("Would you like to print out matrix A and B? (y/n)");
String userResponse = userInput.next();
if (userResponse.equalsIgnoreCase("y")) {
System.out.println("Matrix A:");
printBackMatrix(matrixA);
System.out.println();
System.out.println("Matrix B:");
printBackMatrix(matrixB);
System.out.println();
}
int[][] matrixProduct3 = multMatrixWithThreadsSync(matrixA, matrixB);
String fileName = "test.txt";
System.out.println("Matrix product is being written to " + fileName);
try {
printMatrixToFile(matrixProduct3, fileName);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static int[][] multMatrixWithThreadsSync(int[][] matrixA, int[][] matrixB) {
int[][] matrixProduct = new int[matrixA.length][matrixB[0].length];
int[] matrixProductColumn = new int[matrixA.length];
//
ConcurrentMatrixMultiplyingTask.ConcurrencyContext context = new ConcurrentMatrixMultiplyingTask.ConcurrencyContext(matrixProduct.length);
//
Runnable task = new ConcurrentMatrixMultiplyingTask(context, matrixA, matrixB, matrixProduct);
Thread[] workers = new Thread[5];
for (int i = 0; i < workers.length; i++) {
workers[i] = new Thread(task, "Worker-"+i);
}
for (int i = 0; i < workers.length; i++) {
Thread worker = workers[i];
worker.start();
}
for (int i = 0; i < workers.length; i++) {
Thread worker = workers[i];
try {
worker.join();
} catch (InterruptedException ex) {
Logger.getLogger(MatrixMulti.class.getName()).log(Level.SEVERE, null, ex);
}
}
return matrixProduct;
}
private static void printMatrixToFile(int[][] matrix, String fileName) throws IOException {
PrintWriter userOutput = new PrintWriter(new FileWriter(fileName));
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
userOutput.print(matrix[i][j] + " ");
}
userOutput.println();
}
userOutput.close();
}
private static void printBackMatrix(int[][] matrix) {
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
}
private static void fillMatrix(int[][] matrix) {
Random rand = new Random();
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
matrix[i][j] = rand.nextInt(100) + 1;
}
}
}
public static boolean validDimension(int dim) {
if (dim <= 0 || dim > 1000) {
System.err.println("Dimension value entered is not valid");
return false;
}
return true;
}
}