本文主要介绍了java中synchronized Lock(本地同步)锁的8种情况，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
正文
java中synchronized Lock(本地同步)锁的8种情况
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锁内容请搜索米米素材网以前的文章或继续浏览下面的相关文章希望大家以后多多支持米米素材网！
原文链接：https://www.cnblogs.com/A-Dun/p/15327581.html
发表评论