debug的勇士

debug的勇士

关注
发信
关注(28)粉丝(399)

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

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();
    }
}

synchronized Lock（本地同步）锁的8种情况-LMLPHP

lock2

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同时输出

synchronized Lock（本地同步）锁的8种情况-LMLPHP

lock3

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

synchronized Lock（本地同步）锁的8种情况-LMLPHP

lock4

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

synchronized Lock（本地同步）锁的8种情况-LMLPHP

lock5

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紧随其后

synchronized Lock（本地同步）锁的8种情况-LMLPHP

lock6

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也是锁住的类元信息

synchronized Lock（本地同步）锁的8种情况-LMLPHP

lock7

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

synchronized Lock（本地同步）锁的8种情况-LMLPHP

lock8

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

synchronized Lock（本地同步）锁的8种情况-LMLPHP

09-24 05:18
Powered by LMLPHP ©2024 debug的勇士 0.030321