使用synchronized对并发性的影响

合集 - Java(12)

1.Java中“==”与equals()2023-03-192.Java容器及其常用方法汇总2023-03-19

3.使用synchronized对并发性的影响2023-03-19

4.Java线程池详解2023-03-195.正则表达式（Regular Expression）详解2023-03-196.JVM详解2023-03-197.大数运算（BigInteger）与进制转换2023-03-198.优先队列（PriorityQueue）常用方法及简单案例2023-03-199.Lambda 表达式总结2023-03-1910.Optional 详解2023-03-1911.Stream 总结2023-03-1912.浮点数编码原理2023-03-19

收起

1 前言

• 非静态方法的同步锁是当前对象（this）（对象锁）
• 静态方法的同步锁是当前类的字节码（类锁）
• 不同的锁之间能并发

2 同一对象内

本节主类与资源类如下：

class Resorce{ //资源
	static int x=0;
	static int y=0;
}

public class Main {
	public static void main(String[] args) {
		Operate op=new Operate();
		Thread t1=new Thread() {
			public void run() {
				op.fun1();
			}
		};
		Thread t2=new Thread() {
			public void run() {
				op.fun2();
			}
		};
		t1.start();
		t2.start();
	}
}

2.1 两个非static方法，一个被synchronized修饰，一个未被修饰，能否并发？（能并发）

（本例中两个方法访问同一资源，能并发；若访问不同资源，也能并发）

class Operate{
	void fun1() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t1-uux:"+Resorce.x);
		}
	}
	
	synchronized void fun2() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t2-sux:"+Resorce.x);
		}
	}
}

运行结果：

t1-sux:2
t2-uux:2
t2-uux:4
t1-sux:3
t1-sux:6
t2-uux:5

sux：被synchronized修饰，未被static修饰，资源为x；

uux：未被synchronized修饰，未被static修饰，资源为x。

2.2 两个非static方法，都被synchronized修饰，能否并发？（不能并发）

（本例中两个方法访问不同资源，不能并发；若访问同一资源，也不能并发）

class Operate{
	synchronized void fun1() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t1-sux:"+Resorce.x);
		}
	}
	
	synchronized void fun2() {
		for(int i=0;i<3;i++) {
			Resorce.y++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t2-suy:"+Resorce.y);
		}
	}
}

运行结果：

t1-sux:1
t1-sux:2
t1-sux:3
t2-suy:1
t2-suy:2
t2-suy:3

sux：被synchronized修饰，未被static修饰，资源为x；

suy：被synchronized修饰，未被static修饰，资源为y。

2.3 两个synchronized方法，一个被static修饰，一个未被修饰，能否并发？（能并发）

（本例中两个方法访问同一资源，能并发；若访问不同资源，也能并发）

class Operate{
	synchronized void fun1() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t1-sux:"+Resorce.x);
		}
	}
	
	synchronized static void fun2() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t2-ssx:"+Resorce.x);
		}
	}
}

运行结果：

t1-ssx:2
t1-ssx:3
t2-sux:2
t1-ssx:4
t2-sux:5
t2-sux:6

ssx：被synchronized修饰，被static修饰，资源为x；

sux：被synchronized修饰，未被static修饰，资源为x。

2.4 两个static方法，都被synchronized修饰，能否并发？（不能并发）

（本例中两个方法访问不同资源，不能并发；若访问同一资源，也不能并发）

class Operate{
	synchronized static void fun1() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t1-ssx:"+Resorce.x);
		}
	}
	
	synchronized static void fun2() {
		for(int i=0;i<3;i++) {
			Resorce.y++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t2-ssy:"+Resorce.y);
		}
	}
}

运行结果：

t1-ssx:1
t1-ssx:2
t1-ssx:3
t2-ssy:1
t2-ssy:2
t2-ssy:3

ssx：被synchronized修饰，被static修饰，资源为x；

ssy：被synchronized修饰，被static修饰，资源为y。

3 不同对象间

针对第2节中的两种不能并发的情况进行讨论，主类和资源类如下：

class Resorce{ //临界资源
	static int x=0;
	static int y=0;
}

public class Main {
	public static void main(String[] args) {
		Operate op1=new Operate();
		Operate op2=new Operate();
		Thread t1=new Thread() {
			public void run() {
				op1.fun1();
			}
		};
		Thread t2=new Thread() {
			public void run() {
				op2.fun2();
			}
		};
		t1.start();
		t2.start();
	}
}

3.1 两个非static方法，都被synchronized修饰，能否并发？（能并发）

（本例中两个方法访问同一资源，能并发；若访问不同资源，也能并发）

class Operate{
	synchronized void fun1() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t1-sux:"+Resorce.x);
		}
	}

	synchronized void fun2() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t2-sux:"+Resorce.x);
		}
	}
}

运行结果：

t2-sux:2
t1-sux:2
t1-sux:4
t1-sux:5
t2-sux:3
t2-sux:6

sux：被synchronized修饰，未被static修饰，资源为x。

3.2 两个static方法，都被synchronized修饰，能否并发？（不能并发）

（本例中两个方法访问不同资源，不能并发；若访问同一资源，也不能并发）

class Operate{
	synchronized static void fun1() {
		for(int i=0;i<3;i++) {
			Resorce.x++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t1-ssx:"+Resorce.x);
		}
	}
	
	synchronized static void fun2() {
		for(int i=0;i<3;i++) {
			Resorce.y++;
			for(int j=0;j<1000;j++); //延时
			System.out.println("t2-ssy:"+Resorce.y);
		}
	}
}

运行结果：

t1-ssx:1
t1-ssx:2
t1-ssx:3
t2-ssy:1
t2-ssy:2
t2-ssy:3

ssx：被synchronized修饰，被static修饰，资源为x；

ssy：被synchronized修饰，被static修饰，资源为y。

4 注意事项

这里的资源不是临界资源，临界资源由信号量来控制其访问。

​ 声明：本文转自使用synchronized对并发性的影响