Java 类锁和静态锁

其他 2019-06-11 03:22:20 阅读次数: 0

Java的锁分为两种：

  • 对象锁（又称实例锁，synchronized）：该锁针对的是该实例对象（当前对象）。
    synchronized是对类的当前实例（当前对象）进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例”， 类的两个不同实例就没有这种约束了。
    每个对象都有一个锁，且是唯一的。

  • 类锁（又称全局锁，static synchronized）：该锁针对的是类，无论实例出多少个对象，那么线程依然共享该锁。
    static synchronized是限制多线程中该类的所有实例同时访问该类所对应的代码块。（实例.fun实际上相当于class.fun）

下面来进行几种情况的测试：一下都是用来测试锁的范围

1、两个静态方法都加锁

package test2;

public class Test2 {
	public synchronized void add(){
		System.out.println("1 :) ");
		t();
	}
	public void add1(){
		System.out.println("2 :( ");
		t();
	}
	public void t(){
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

 2、两个非静态方法都加锁

package test2;

public class Test1 extends Thread{
	private int flag;
	
	private Test2 t;
	
	public Test1(int f , Test2 t2){
		flag = f;
		t = t2;
	}
	
	public void run(){
		if(flag == 1)
			try {
//				Test2.add();
				t.add();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		if(flag == 2)
			try {
				t.add1();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public static void main(String[] args) throws InterruptedException {
		Test2 t = new Test2();
		Test1 t1 = new Test1(1,t);
		Test1 t2 = new Test1(2,t);
		t1.start();
		t2.start();
	}
}

class Test2 {
	public synchronized  void add(){
		System.out.println("1 :) "+System.currentTimeMillis());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public synchronized void add1(){
		System.out.println("2 :( "+System.currentTimeMillis());
	}
	
}

结果：此时会锁住加锁的另外一个对象

 

3、非静态方法、静态方法都加锁

package test2;

public class Test1 extends Thread{
	private int flag;
	
	private Test2 t;
	
	public Test1(int f , Test2 t2){
		flag = f;
		t = t2;
	}
	
	public void run(){
		if(flag == 1)
			try {
				Test2.add();
//				t.add();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		if(flag == 2)
			try {
				t.add1();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public static void main(String[] args) throws InterruptedException {
		Test2 t = new Test2();
		Test1 t1 = new Test1(1,t);
		Test1 t2 = new Test1(2,t);
		t1.start();
		t2.start();
	}
}

class Test2 {
	public synchronized static void add(){
		System.out.println("1 :) "+System.currentTimeMillis());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public synchronized void add1(){
		System.out.println("2 :( "+System.currentTimeMillis());
	}
	
}

结果：静态带锁的对象锁不住不带锁的非静态方法

 

4、静态方法加锁、非静态方法不加锁

package test2;

public class Test1 extends Thread{
	private int flag;
	
	private Test2 t;
	
	public Test1(int f , Test2 t2){
		flag = f;
		t = t2;
	}
	
	public void run(){
		if(flag == 1)
			try {
				Test2.add();
//				t.add();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		if(flag == 2)
			try {
				t.add1();
//				Test2.add1();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public static void main(String[] args) throws InterruptedException {
		Test2 t = new Test2();
		Test1 t1 = new Test1(1,t);
		Test1 t2 = new Test1(2,t);
		t1.start();
		t2.start();
	}
}

class Test2 {
	public synchronized static void add(){
		System.out.println("1 :) "+System.currentTimeMillis());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void add1(){
		System.out.println("2 :( "+System.currentTimeMillis());
	}
	
}

结果：静态方法加锁，锁不住非静态方法

5、非静态方法加锁、静态方法不加锁

package test2;

public class Test1 extends Thread{
	private int flag;
	
	private Test2 t;
	
	public Test1(int f , Test2 t2){
		flag = f;
		t = t2;
	}
	
	public void run(){
		if(flag == 1)
			try {
				Test2.add();
//				t.add();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		if(flag == 2)
			try {
				t.add1();
//				Test2.add1();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public static void main(String[] args) throws InterruptedException {
		Test2 t = new Test2();
		Test1 t1 = new Test1(1,t);
		Test1 t2 = new Test1(2,t);
		t1.start();
		t2.start();
	}
}

class Test2 {
	public static void add(){
		System.out.println("1 :) "+System.currentTimeMillis());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public synchronized void add1(){
		System.out.println("2 :( "+System.currentTimeMillis());
	}
	
}

结果：还是锁不住！！！

 

6、两个静态方法，一个加锁一个不加锁

package test2;

public class Test1 extends Thread{
	private int flag;
	
	private Test2 t;
	
	public Test1(int f , Test2 t2){
		flag = f;
		t = t2;
	}
	
	public void run(){
		if(flag == 1)
			try {
				Test2.add();
//				t.add();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		if(flag == 2)
			try {
//				t.add1();
				Test2.add1();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public static void main(String[] args) throws InterruptedException {
		Test2 t = new Test2();
		Test1 t1 = new Test1(1,t);
		Test1 t2 = new Test1(2,t);
		t1.start();
		t2.start();
	}
}

class Test2 {
	public synchronized static void add(){
		System.out.println("1 :) "+System.currentTimeMillis());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public static void add1(){
		System.out.println("2 :( "+System.currentTimeMillis());
	}
	
}

结果：静态方法加锁，锁不住不加锁的静态方法

 

7、两个非静态方法，一个加锁一个不加锁

package test2;

public class Test1 extends Thread{
	private int flag;
	
	private Test2 t;
	
	public Test1(int f , Test2 t2){
		flag = f;
		t = t2;
	}
	
	public void run(){
		if(flag == 1)
			try {
//				Test2.add();
				t.add();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		if(flag == 2)
			try {
				t.add1();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public static void main(String[] args) throws InterruptedException {
		Test2 t = new Test2();
		Test1 t1 = new Test1(1,t);
		Test1 t2 = new Test1(2,t);
		t1.start();
		t2.start();
	}
}

class Test2 {
	private int i = 0;
	public synchronized  void add(){
		System.out.println("1 :) "+System.currentTimeMillis());
	}
	public void add1(){
		System.out.println("2 :( "+System.currentTimeMillis());
	}
	
}

执行结果：可以看到，加锁后的非静态方法，锁不住不加锁的静态方法

 

8、两个非静态方法，一个加锁，一个不加锁，调用相同的方法

package test2;

public class Test1 extends Thread{
	private int flag;
	
	private Test2 t;
	
	public Test1(int f , Test2 t2){
		flag = f;
		t = t2;
	}
	
	public void run(){
		if(flag == 1)
			try {
//				Test2.add();
				t.add();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		if(flag == 2)
			try {
				t.add1();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public static void main(String[] args) {
		Test2 t = new Test2();
		Test1 t1 = new Test1(1,t);
		Test1 t2 = new Test1(2,t);
		t1.start();
		t2.start();
	}
}

class Test2 {
	public synchronized  void add(){
		System.out.println("1 :) "+System.currentTimeMillis());
		t();
	}
	public void add1(){
		System.out.println("2 :( "+System.currentTimeMillis());
		t();
	}
	public void t(){
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

结果:并不会在add方法里锁住t()方法

 

9、两个非静态方法，一个加锁，一个不加锁，调用相同的方法对同一个变量进行操作

package test2;

public class Test1 extends Thread{
	private int flag;
	
	private Test2 t;
	
	public Test1(int f , Test2 t2){
		flag = f;
		t = t2;
	}
	
	public void run(){
		if(flag == 1)
			try {
//				Test2.add();
				t.add();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		if(flag == 2)
			try {
				t.add1();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	public static void main(String[] args) throws InterruptedException {
		Test2 t = new Test2();
		for(int i = 0 ; i < 1000 ; i++){
			Test1 t1 = new Test1(1,t);
			Test1 t2 = new Test1(2,t);
			t1.start();
			t2.start();
		}
		Thread.sleep(30);
		System.out.println(t.getI());
	}
}

class Test2 {
	private int i = 0;
	public synchronized  void add(){
//		System.out.println("1 :) "+System.currentTimeMillis());
		t();
	}
	public void add1(){
//		System.out.println("2 :( "+System.currentTimeMillis());
		t();
	}
	public void t(){
		try {
			i++;
//			Thread.sleep(5000);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public int getI() {
		return i;
	}
	public void setI(int i) {
		this.i = i;
	}
	
}

结果：一个方法加锁也不会保证其调用方法的操作变量的安全性

总结：不管是什么锁，都只能锁住相同类型（静态-静态，非静态-非静态）的带锁的对象。 

猜你喜欢

转载自blog.csdn.net/qq_39429962/article/details/85005972
今日推荐
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
周排行
static方法和非static方法的区别（java）
如何查找计算机专业paper
java.lang.ClassFormatError: Incompatible magic value 0 in class file com/sitecha
跳跃游戏II
stm32_之【建立工程】
TeaWeb v0.0.9 发布，统计底层优化、主机监控功能改进
事件分发 -----控制字体大小
JavaScript DOM练习（动态表格添加） December 25，2019
JSF Scope & CDI
实现从零搭建一个登录注册页面（附源代码）
每日归档
更多
2024-05-19(0)
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022