java：对象锁与类锁的深入理解

骑猪看日落 2023-07-01 07:29 75阅读 0赞

### 一、synchronized锁 ###

> **synchronized**是java的一个关键字，它能够将代码块锁起来，一次只能允许一个线程进入被锁住的代码块。(需要掌握多线程的基本知识)  
> 类锁与对象锁属于synchronized锁。

### 二、类锁与对象锁 ###

1、我们首先需要知道什么是类锁？什么是对象锁？

> **简单来讲，synchronized修饰静态方法获取的是类锁(类的字节码文件对象)，synchronized修饰普通方法或代码块获取的是对象锁。**

2、第二我们需要知道哪些情况锁是可以相互锁住，哪些相互锁不住？

> 类锁与类锁之间是相互能锁定的，对象锁与对象锁之间是相互能锁定的。但是对象锁与类锁是相互锁不住的。

代码解释：

public class DataTest { 
    	
    	//静态的属于类 , 非静态的属于对象
    	
    	public synchronized void method1() { 
    		System.out.println("俺是方法1--1");
    		
    		try { 
    			Thread.sleep(2000);
    		} catch (InterruptedException e) { 
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		System.out.println("俺是方法1---2");
    	}
    	
    	public  synchronized void method2() { 
    		System.out.println("俺是方法2---1");
    		
    		try { 
    			Thread.sleep(3000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		System.out.println("俺是方法2---2");
    	}
    	
    	public static synchronized void method3() {    //这是一个静态方法，属于类
            System.out.println("俺是方法3---1");
    
            try { 
                Thread.sleep(3000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("俺是方法3---2");
        }
    }

（1）、测试对象锁与对象锁

public class Demo { 
    
        public static void main(String[] args) { 
            DataTest d = new DataTest();
    
            Thread t1 = new Thread(new Thread(){ 
                    public void run(){ 
                        d.method1();
                    }
            });
    
            Thread t2 = new Thread(new Thread(){ 
                public void run(){ 
                    d.method2();
                }
            });
    
            //启动线程
            t1.start();
            t2.start();
        }
    }

运行结果及其分析：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTIyMTEz_size_16_color_FFFFFF_t_70]  
从输出结果我们可以看出，对于对象锁与对象锁的验证，当锁定一个线程的时候，另一个线程是无法进入访问的，另一个线程只有当上一个线程访问结束以后才能访问。（类锁与类锁相同）

（2）、测试对象锁与类锁

public class ThreadDemo { 
    
        public static void main(String[] args) { 
            DataTest d = new DataTest();
    
            Thread t1 = new Thread(new Thread(){ 
                    public void run(){ 
                        d.method1();
                    }
            });
    
            Thread t2 = new Thread(new Thread(){ 
                public void run(){ 
                    DataTest.method3();//静态方法属于类，可直接通过类来访问
                }
            });
    
            //启动线程
            t1.start();
            t2.start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTIyMTEz_size_16_color_FFFFFF_t_70 1]从结果分析可以看出，t1在对method1还未访问完，t2已经开始了对method3进行了执行，从这里我们可以得到，对象锁与类锁是相互锁不住的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTIyMTEz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200119211442638.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTIyMTEz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTIyMTEz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200119212536430.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTIyMTEz,size_16,color_FFFFFF,t_70