Java 矩阵类 实现加法、减法和乘法

/*
 MatrixDemo.java
 2012-11-7 
*/
import java.util.*;

class Matrix{
	int row , column;
	double[][] matrix;
	//构造函数
	Matrix(double[][] matrix){
		this.row = matrix.length;
		this.column = matrix[0].length;
		this.matrix = new double[this.row][this.column];
		for(int i = 0 ; i < this.row ; i++)
			for(int j = 0 ; j < this.column ; j++)
				this.matrix[i][j] = matrix[i][j];
	}
	//矩阵加法
	Matrix add(Matrix mat2){
		double[][] add_result = new double[this.row][this.column];
		for(int i = 0 ; i < this.row ; i++)
			for(int j = 0 ; j < this.column ; j++)
				add_result[i][j] = this.matrix[i][j]+mat2.matrix[i][j];
		return new Matrix(add_result);
	}
	//矩阵减法
	Matrix minus(Matrix mat2){
		double[][] add_result = new double[this.row][mat2.column];
		for(int i = 0 ; i < this.row ; i++)
			for(int j = 0 ; j < this.column ; j++)
				add_result[i][j] = this.matrix[i][j]-mat2.matrix[i][j];
		return new Matrix(add_result);
	}
	//矩阵乘法
	Matrix multiply(Matrix mat2){
		double[][] multiply_result = new double[this.row][mat2.column];
		for(int i = 0 ; i < this.row ; i++ )
			for(int j = 0 ; j < mat2.column ; j++)
				for(int k = 0 ; k < mat2.row ; k++ ){
					multiply_result[i][j] += this.matrix[i][k]*mat2.matrix[k][j];  
				}
		return new Matrix(multiply_result);
	}
	//打印函数
	void print(){
		for(int i = 0 ; i < this.row ; i++){
			for(int j = 0 ; j < this.column ; j++){
				System.out.print(this.matrix[i][j] + " ");	
			}
			System.out.println();
		}
	}
}



public class MatrixDemo {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int row , column;
		String select , judge;
		
		//第一个矩阵
		System.out.println("输入第一个矩阵的行数和列数:");
		row = sc.nextInt();
		column = sc.nextInt();
		double[][] m = new double[row][column];
		System.out.println("设置第一个矩阵:");
		for(int i = 0 ; i < row ; i++)
			for(int j = 0 ; j < column ; j++)
				m[i][j] = sc.nextDouble();
		Matrix matrix1 = new Matrix(m);
		//第二个矩阵
		System.out.println("输入第二个矩阵的行数和列数:");
		row = sc.nextInt();
		column = sc.nextInt();
		m = new double[row][column];
		System.out.println("设置第二个矩阵:");
		for(int i = 0 ; i < row ; i++)
			for(int j = 0 ; j < column ; j++)
				m[i][j] = sc.nextDouble();
		Matrix matrix2 = new Matrix(m);
		//选择要进行的运算
		while(true){
			System.out.println("选择要进行的运算(+/-/*):");
			select = sc.next();
			if(select.equals("+")){
				if(matrix1.row != matrix2.row || matrix1.column != matrix2.column){
					System.out.println("错误!不符合矩阵运算法则!");
				}
				else{
					Matrix matrix3 = matrix1.add(matrix2);
					System.out.println("矩阵相加 =");
					matrix3.print();
				}
			}
			if(select.equals("-")){
				if(matrix1.row != matrix2.row || matrix1.column != matrix2.column){
					System.out.println("错误!不符合矩阵运算法则!");
				}
				else{
					Matrix matrix3 = matrix1.minus(matrix2);
					System.out.println("矩阵相减 =");
					matrix3.print();
				}
			}
			if(select.equals("*")){
				if(matrix1.column != matrix2.row){
					System.out.println("错误!不符合矩阵运算法则!");
				}
				else
				{
					Matrix matrix3 = matrix1.multiply(matrix2);
					System.out.println("矩阵相乘 =");
					matrix3.print();
				}
			}
			System.out.println("选择其它运算?(Y/N)");
			judge = sc.next();
			if(judge.equals("Y")|judge.equals("y"))
				continue;
			else
				break;
		}
		sc.close();

	}

}
java新手 写的不好
在 Java 中,`synchronized` 是一种基于对象头实现的同步机制,用于控制多个线程对共享资源的访问。为了提升性能,JVM 对 `synchronized` 进行了优化,引入了升级机制,包括从**偏向**、**轻量级**到**重量级**的演变过程[^1]。 ### 偏向(Biased Locking) 偏向是为了解决无竞争情况下的获取开销而设计的。当一个线程访问同步块并成功获取后,JVM 会将该对象头中的 Mark Word 设置为偏向状态,并记录持有的线程 ID。后续该线程再进入同步块时,无需进行 CAS 操作即可直接执行临界区代码,从而减少同步带来的性能损耗[^3]。 例如,以下代码中,第一调用 `synchronized` 时可能会触发偏向: ```java Object lock = new Object(); new Thread(() -> { synchronized (lock) { // 第一获取,可能升级为偏向 } }).start(); ``` 一旦有其他线程尝试获取偏向就会被撤销,并升级为轻量级。 ### 轻量级(Lightweight Locking) 当多个线程同时竞争同一个时,JVM 会尝试使用自旋的方式让线程等待的释放,而不是立即阻塞线程。这种方式称为轻量级。线程会在用户态不断尝试获取,避免了线程上下文切换的开销。如果自旋数超过阈值或竞争加剧,则会进一步升级为重量级轻量级的实现依赖于线程栈帧中的记录(Lock Record)和对象头的 Mark Word 进行 CAS 替换操作。若替换成功则获得,否则进入自旋等待。 ### 重量级(Heavyweight Locking) 当轻量级无法通过自旋获取时,JVM 会将升级为重量级。此时线程会被挂起并进入操作系统内核态的阻塞状态,等待的释放。这种状态涉及线程调度器介入,会产生较大的性能开销,尤其是在频繁发生竞争的场景下[^2]。 重量级的本质是依赖操作系统的互斥量(mutex)来实现线程阻塞与唤醒,因此其性能成本远高于前两种状态。 ### 升级流程总结 - **初始状态**:无。 - **首访问**:偏向,记录线程 ID。 - **竞争出现**:撤销偏向,升级为轻量级,采用自旋机制。 - **自旋失败或竞争激烈**:升级为重量级,线程进入阻塞状态等待唤醒[^1]。 ### 性能影响与优化建议 的升级机制旨在平衡性能与并发安全之间的关系。偏向适用于单线程访问场景,轻量级适用于低竞争环境,而重量级则应对高竞争场景。合理使用粒度、减少持有时间、避免不必要的同步操作,有助于降低升级频率,提高系统吞吐量。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值