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

2021年9月24日 11点热度 0条评论 来源: debug的勇士

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再输出

    原文作者:debug的勇士
    原文地址: https://www.cnblogs.com/A-Dun/p/15327581.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。