java中synchronized Lock(本地同步)锁的8种情况

更新时间：2021年09月24日 08:34:17 作者：A.Dun

本文主要介绍了java中synchronized Lock(本地同步)锁的8种情况，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

* 题目：
* 1.标准访问，请问是先打印邮件还是短信 Email
* 2.email方法新增暂停4秒钟，请问是先打印邮件还是短信 Email
* 3.新增普通的hello方法，请问先打印邮件还是hello hello
* 4.两部手机，请问先打印邮件还是短信 SMS
* 5.两个静态同步方法，1部手机，请问先打印邮件还是短信 Email
* 6.两个静态同步方法，2部手机，请问先打印邮件还是短信 Email
* 7.一个普通同步方法，一个静态同步方法，1部手机，请问先打印邮件还是短信 SMS
* 8.一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信 SMS
*
* lock1、2
* 一个对象里面如果有多个synchronized方法，某一时刻内，只要一个线程去调用其中的一个synchronized方法，
* 其他的线程都只能等待，换句话说，某一时刻内，只能有唯一一个线程去访问这些synchronized方法，
* 锁的是当前对象的this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
*
* lock3、4
* 加个普通的方法后和同步锁无关
* 换成两个对象后，不是同一把锁了，情况立刻变化
*
* lock5、6
* 都换成静态同步方法后，情况又变化（静态锁的是Class类对象）
* 若是普通同步方法，new this，具体的一部一部手机，所有的普通同步方法用的都是同一把锁----示例对象本身
* 若是静态同步方法，static class，唯一的一个模板
* synchronized是实现同步的基础：Java中的每一个对象都可以作为锁
* 具体表现为一下3种形式。
* 对于普通同步方法，锁是当前实例对象。它等同于对于同步方法块，锁是synchronized括号里的配置的对象。
* 对于静态同步方法，锁是当前类的Class类元信息
*
* lock7、8
* 当一个线程试图访问同步代码块时它首先必须得到锁，退出或抛出异常时必须释放锁
*
* 所有的同步方法用的都是同一把锁----实例对象本身，就是new出来的具体实例对象本身
* 也就是说如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获得锁
* 可是别的实例对象的普通同步方法因为跟该实例对象的普通同步方法用到是不同锁，所以不用等待该实例对象已获取锁的普通
* 同步方法释放锁就可以获取它们自己的锁
*
* 所有的静态同步方法用的也是同一把锁----类对象本身，就是我们说过的唯一模板Class
* 具体实例对象this和唯一模板Class，这两把锁是两个不同的对象，所有静态同步方法与普通同步方法之间是不会有竞态条件的，
* 但是一旦一个静态同方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

lock1、2、3一个实例对象

lock4、5、6、7、8两个实例对象

lock1

1.标准访问，请问是先打印邮件还是短信？答案：Email

sendEmail()与sendSms()都是普通同步方法，都使用synchronized锁

这里按方法调用顺序，依次执行，当前synchronized锁住的是同一个实例对象

package day02_lam;
 
import java.util.concurrent.TimeUnit;
 
class Phone{
    public synchronized void sendEmail() throws InterruptedException{
         System.out.println("------------sendEmail");
    }

    public  synchronized void sendSms(){
     System.out.println("------------sendSMS");
    }

}
 
/**
*题目：
*1.标准访问，请问是先打印邮件还是短信     Email
*/
public class Lock8{
	public static void main(String[] args) throws InterruptedException{
        Phone phone=new Phone();
        //线程A发送Email
        new Thread(()->{
                try{
                    phone.sendEmail();
                }catch(InterruptedExceptione){
                    e.printStackTrace();
                }
            },"A").start();

        Thread.sleep(300);
        
        //线程B发送短信
        newThread(()->{
            phone.sendSms();
        },"B").start();
    }
}

lock2

2.email方法新增暂停4秒钟，请问是先打印邮件还是短信？答案：Email

lock2是lock1的变形，其原理与lock1一致，synchronized锁住的是同一个对象，必须等到第一个方法把锁释放后，第二个方法才能够获得锁

package day02_lam;

import java.util.concurrent.TimeUnit;

class Phone{
	public synchronized void sendEmail()throwsInterruptedException{
        //睡眠4秒种
		TimeUnit.SECONDS.sleep(4);
		System.out.println("------------sendEmail");
	}
	
	public synchronized void sendSms(){
		System.out.println("------------sendSMS");
	}

}

/**
*题目：
*1.标准访问，请问是先打印邮件还是短信Email
*2.email方法新增暂停4秒钟，请问是先打印邮件还是短信Email
*/
public class Lock8{
    public static void main(String[] args)throws InterruptedException{
        //资源类
        Phone phone=new Phone();
		
        //线程A sendEmail
        newThread(()->{
            try{
                phone.sendEmail();
            }catch(InterruptedExceptione){
                e.printStackTrace();
            }
        },"A").start();

		//这里保证线程A能够执行完
   	 	Thread.sleep(300);

        //线程B sendSms
        newThread(()->{
            phone.sendSms();
        },"B").start();

    }
}

结果：等待4秒中后出现sendEmail与sendSMS同时输出

lock3

3.新增普通的hello方法，请问先打印邮件还是hello? 答案：hello

只有添加synchronized关键字的方法才会被synchronized锁控制

package day02_lam;

import java.util.concurrent.TimeUnit;

class Phone{
	public synchronized void sendEmail()throws InterruptedException{
		TimeUnit.SECONDS.sleep(4);
		System.out.println("------------sendEmail");
	}

	public synchronized void sendSms(){
		System.out.println("------------sendSMS");
	}

	public void hello(){//未加synchronized
		System.out.println("hello");
	}
}

/**
*题目：
*1.标准访问，请问是先打印邮件还是短信Email
*2.email方法新增暂停4秒钟，请问是先打印邮件还是短信Email
*3.新增普通的hello方法，请问先打印邮件还是hello    hello
*/
public  class Lock8{
    public static void main(String[] args)throws InterruptedException{
        Phone phone=new Phone();
		
        //线程A调用sendEmail
        new Thread(()->{
            try{
                phone.sendEmail();
            }catch(InterruptedExceptione){
                e.printStackTrace();
            }
        },"A").start();

   		Thread.sleep(300);

       	//线程B调用普通方法hello
        new Thread(()->{
            //phone.sendSms();
            phone.hello();
        },"B").start();

    }
}

结果：hello先输出，4s后sendEmail再输出

lock4

4.两部手机，请问先打印邮件还是短信 ？答案：SMS

不同实例对象，synchronized锁住的是对应的调用对象

package day02_lam;

import java.util.concurrent.TimeUnit;

class Phone{
	public synchronized void sendEmail()throws InterruptedException{
        //睡眠4秒种
		TimeUnit.SECONDS.sleep(4);
		System.out.println("------------sendEmail");
	}
	
	public synchronized void sendSms(){
		System.out.println("------------sendSMS");
	}
	
	public void hello(){
		System.out.println("hello");
	}
}

/**
*题目：
*1.标准访问，请问是先打印邮件还是短信Email
*2.email方法新增暂停4秒钟，请问是先打印邮件还是短信Email
*3.新增普通的hello方法，请问先打印邮件还是hellohello
*4.两部手机，请问先打印邮件还是短信 SMS
*/
public class Lock8{
public static void main(String[] args)throws InterruptedException{
		Phone phone=new Phone();
		Phone phone2=new Phone();
	
		//sychronized锁定是当前对象对应的this，phone与phone2分别锁的是自己的this
		
    	//线程A使用实例phone调用sendEmail
		newThread(()->{
			try{
                //sendEmail方法中包含睡眠4秒种
				phone.sendEmail();
			}catch(InterruptedExceptione){
				e.printStackTrace();
			}
		},"A").start();
	
		Thread.sleep(300);
	
    	//线程B使用实例phone2调用sendSms
		newThread(()->{
			phone2.sendSms();
			//phone.hello();
		},"B").start();
	
	}
}

结果：sendSMS先输出，4s后sendEmail再输出

lock5

5.两个静态同步方法，1部手机，请问先打印邮件还是短信? 答案：Email

synchronized锁静态方法，实际是锁住的类元信息，因为静态方法是随类元信息的加载而保存到jvm的静态区，是所有实例创建的模板

package day02_lam;

import java.util.concurrent.TimeUnit;

class Phone{
	public static synchronized void sendEmail()throws InterruptedException{
		TimeUnit.SECONDS.sleep(4);
		System.out.println("------------sendEmail");
	}
	
	public static synchronized void sendSms(){
	
		System.out.println("------------sendSMS");
	}
	
	public void hello(){
		System.out.println("hello");
	}
}

/**
*题目：
*1.标准访问，请问是先打印邮件还是短信Email
*2.email方法新增暂停4秒钟，请问是先打印邮件还是短信Email
*3.新增普通的hello方法，请问先打印邮件还是hellohello
*4.两部手机，请问先打印邮件还是短信SMS
*5.两个静态同步方法，1部手机，请问先打印邮件还是短信 Email
*/
public class Lock8{
public  static void main(String[] args)throws InterruptedException{
	Phone phone=new Phone();
	
	new Thread(()->{
		try{
			phone.sendEmail();
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	},"A").start();
	
	Thread.sleep(300);
	
	newThread(()->{
		phone.sendSms();
	},"B").start();
	
	}
}

结果：4秒种后，sendEmail率先输出，sendSMS紧随其后

lock6

6.两个静态同步方法，2部手机，请问先打印邮件还是短信？答案：Email

与lock5的运行结果一致，当前synchronized锁住的是类元信息

package day02_lam;

import java.util.concurrent.TimeUnit;

class Phone{
    public static synchronized void sendEmail() throws InterruptedException{
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------------sendEmail");
    }

    public static synchronized void sendSms(){
    	System.out.println("------------sendSMS");
    }

    public void hello(){
   	 	System.out.println("hello");
    }
}

/**
*题目：
*1.标准访问，请问是先打印邮件还是短信Email
*2.email方法新增暂停4秒钟，请问是先打印邮件还是短信Email
*3.新增普通的hello方法，请问先打印邮件还是hellohello
*4.两部手机，请问先打印邮件还是短信SMS
*5.两个静态同步方法，1部手机，请问先打印邮件还是短信Email
*6.两个静态同步方法，2部手机，请问先打印邮件还是短信Email
*/
public class Lock8{
    publicstaticvoidmain(String[]args)throwsInterruptedException{
        Phone phone=new Phone();
        Phone phone2=new Phone();

        new Thread(()->{
            try{
            	phone.sendEmail();
            }catch(InterruptedException e){
           	 e.printStackTrace();
            }
        },"A").start();
        Thread.sleep(300);
        new Thread(()->{
            //phone.sendSms();
            phone2.sendSms();
            //phone.hello();
        },"B").start();

    }
}

结果：与lock5的运行结果一致，sendEmail与sendSMS都是4s后进行输出，synchronized也是锁住的类元信息

lock7

7.一个普通同步方法，一个静态同步方法，1部手机，请问先打印Email还是SMS？答案：SMS

原理：普通同步方法，synchronized锁住的是当前实例对象，当前实例对象存在于jvm的堆内存区

静态同步方法，synchronized锁住的是当前类的类元信息，存在于jvm元空间的静态区中

package day02_lam;

import java.util.concurrent.TimeUnit;

class Phone{
    //静态同步方法
	public static synchronized void sendEmail()throws InterruptedException{
		TimeUnit.SECONDS.sleep(4);
		System.out.println("------------sendEmail");
	}
	
    //普通同步方法
	public synchronized void sendSms(){//无static
	
		System.out.println("------------sendSMS");
	}
	
	public void hello(){
		System.out.println("hello");
	}
}

/**
*题目：
*1.标准访问，请问是先打印邮件还是短信Email
*2.email方法新增暂停4秒钟，请问是先打印邮件还是短信Email
*3.新增普通的hello方法，请问先打印邮件还是hellohello
*4.两部手机，请问先打印邮件还是短信SMS
*5.两个静态同步方法，1部手机，请问先打印邮件还是短信Email
*6.两个静态同步方法，2部手机，请问先打印邮件还是短信Email
*7.一个普通同步方法，一个静态同步方法，1部手机，请问先打印邮件还是短信 SMS
*/
public class Lock8{
	public static void main(String[] args) throws InterruptedException{
		Phonephone=newPhone();
		Phonephone2=newPhone();
		
		newThread(()->{
			try{
				phone.sendEmail();
			}catch(InterruptedExceptione){
				e.printStackTrace();
			}
		},"A").start();
		
		Thread.sleep(300);
		
		newThread(()->{
			phone.sendSms();
			//phone2.sendSms();
			//phone.hello();
		},"B").start();
	
	}
}

结果：sendSMS先输出，4s后sendEmail再输出

lock8

8.一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？答案：SMS

原理：与lock7一致

package day02_lam;

import java.util.concurrent.TimeUnit;

class Phone{
	public static synchronized void sendEmail()throwsInterruptedException{
		TimeUnit.SECONDS.sleep(3);
		System.out.println("------------sendEmail");
	}
	
	public synchronized void sendSms(){
	
		System.out.println("------------sendSMS");
	}
	
	public void hello(){
		System.out.println("hello");
	}
}

/**
*题目：
*1.标准访问，请问是先打印邮件还是短信Email
*2.email方法新增暂停4秒钟，请问是先打印邮件还是短信Email
*3.新增普通的hello方法，请问先打印邮件还是hellohello
*4.两部手机，请问先打印邮件还是短信SMS
*5.两个静态同步方法，1部手机，请问先打印邮件还是短信Email
*6.两个静态同步方法，2部手机，请问先打印邮件还是短信Email
*7.一个普通同步方法，一个静态同步方法，1部手机，请问先打印邮件还是短信SMS
*8.一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信SMS
*/
public class Lock8{
	publicstaticvoidmain(String[]args)throwsInterruptedException{
		Phone phone=new Phone();
		Phone phone2=new Phone();
		
		new Thread(()->{
			try{
				phone.sendEmail();
			}catch(InterruptedExceptione){
				e.printStackTrace();
			}
		},"A").start();
		
		Thread.sleep(300);
		
		new Thread(()->{
			//phone.sendSms();
			phone2.sendSms();
			//phone.hello();
		},"B").start();
	
	}
}

结果：运行结果与lock7一致，sendSMS先输出，4s后sendEmail再输出

到此这篇关于java中synchronized Lock(本地同步)锁的8种情况的文章就介绍到这了,更多相关 synchronized Lock锁内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

mybatisplus的连表增强插件mybatis plus join
本文主要介绍了mybatisplus的连表增强插件mybatis plus join，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-06-06
Spring IO Platform简单介绍
这篇文章主要介绍了Spring IO Platform简单介绍，具有一定借鉴价值,需要的朋友可以参考下
2017-12-12
java 获取字节码文件的几种方法总结
这篇文章主要介绍了java 获取字节码文件的几种方法总结的相关资料,这里总结了三种方法帮助大家实现该功能，需要的朋友可以参考下
2017-08-08
JAVA开发环境Vs code配置步骤详解
这篇文章主要为大家介绍了JAVA开发环境Vs code配置步骤详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-04-04
Java 中的内存映射 mmap
这篇文章主要介绍了Java 中的内存映射，mmap 是一种内存映射文件的方法，即将一个文件映射到进程的地址空间，实现文件磁盘地址和一段进程虚拟地址的映射，下面来看看详细内容,需要的朋友可以参考一下
2021-11-11
Spring Boot如何使用AOP实例解析
这篇文章主要介绍了Spring Boot如何使用AOP实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-04-04
jmeter下载及安装配置教程(win10平台为例)
Apache JMeter是Apache组织开发的基于Java的压力测试工具，Apache jmeter 可以用于对静态的和动态的资源（文件，Servlet，Perl脚本，java 对象，数据库和查询，FTP服务器等等）的性能进行测试，本文给大家介绍jmeter下载及安装配置过程，感兴趣的朋友一起看看吧
2021-12-12
java 单例模式和工厂模式实例详解
这篇文章主要介绍了Java设计模式编程中的单例模式和简单工厂模式以及实例,使用设计模式编写代码有利于团队协作时程序的维护,需要的朋友可以参考下
2017-04-04
SpringBoot的Admin服务监控详解
这篇文章主要介绍了SpringBoot的Admin服务监控详解,Spring Boot Admin(SBA)是一个开源的社区项目,用于管理和监控 Spring Boot 应用程序,需要的朋友可以参考下
2024-01-01
Eclipse配置maven环境的图文教程
下面小编就为大家带来一篇Eclipse配置maven环境的图文教程。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-11-11