JUC并发编程（五）-8锁的现象
5、8锁的现象
以下名词解释：
顺序执行：先调用的先执行；
随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。
5.1. 多个线程使用同一把锁-顺序执行
1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！
示例1、标准访问，请问先打印邮件还是短信？
package com.interview.concurrent.lock.locakType;
import java.util.concurrent.TimeUnit;
/**
* @author yangxj
* @description 描述
* @date 2020/2/22 15:57
*/
public class MultiThreadUseOneLock01 {
public static void main(String[] args){
Mobile mobile = new Mobile();
// 两个线程使用的是同一个对象。两个线程是一把锁！先调用的先执行！
new Thread(()->mobile.sendEmail(),"A").start();
// 干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->mobile.sendMS(),"B").start();
}
}
// 手机，发短信，发邮件
class Mobile {
// 被 synchronized 修饰的方法、锁的对象是方法的调用者、
public synchronized void sendEmail() {
System.out.println("sendEmail");
}
public synchronized void sendMS() {
System.out.println("sendMS");
}
}
5.2. 多个线程使用同一把锁，其中某个线程里面还有阻塞-顺序先执行
2、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行,即使在某方法中设置了阻塞。
示例2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
package com.interview.concurrent.lock.locakType;
import java.util.concurrent.TimeUnit;
/**
* @author yangxj
* @description 描述
* @date 2020/2/22 15:57
*/
public class MultiThreadUseOneLock02 {
public static void main(String[] args){
Mobile2 mobile = new Mobile2();
// 两个线程使用的是同一个对象。两个线程是一把锁！先调用的先执行！
new Thread(()->mobile.sendEmail(),"A").start();
// 干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->mobile.sendMS(),"B").start();
}
}
// 手机，发短信，发邮件
class Mobile2 {
// 被 synchronized 修饰的方法、锁的对象是方法的调用者、
public synchronized void sendEmail() {
//多个线程使用一把锁，这里设置一个干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendEmail");
}
public synchronized void sendMS() {
System.out.println("sendMS");
}
}
5.3. 多个线程有锁与没锁-随机执行
多个线程，有的线程有锁，有的线程没锁，两者之间不存在竞争同一把锁的情况，先后执行顺序是随机的。
这种情况犹如你跟你老婆下班回家，家里面的厕所是有锁的，卧室没有锁，俩人到家后，你老婆先上厕所（有锁），你可以一直等待你老婆出来，你再去厕所后，才进卧室，你也可以先进卧室，等你老婆出来后，你再进厕所。
示例3、新增一个普通方法接收微信()没有同步,请问先打印邮件还是接收微信？
package com.interview.concurrent.lock.locakType;
import java.util.concurrent.TimeUnit;
/**
* @author yangxj
* @description 描述
* @date 2020/2/22 15:57
*/
public class MultiThreadHaveLockAndNot03 {
public static void main(String[] args){
Mobile3 mobile = new Mobile3();
// 两个线程使用的是同一个对象。两个线程是一把锁！先调用的先执行！
new Thread(()->mobile.sendEmail(),"A").start();
// 干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->mobile.sendMS(),"B").start();
new Thread(()->mobile.getWeixinMs(),"C").start();
}
}
// 手机，发短信，发邮件
class Mobile3 {
// 被 synchronized 修饰的方法、锁的对象是方法的调用者、
public synchronized void sendEmail() {
//多个线程使用一把锁，这里设置一个干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendEmail");
}
public synchronized void sendMS() {
System.out.println("sendMS");
}
//接收微信，没有锁
public void getWeixinMs() {
System.out.println("getWeixinMs");
}
}
5.4. 多个线程使用多把锁-随机执行
1、被 synchronized 修饰的方法，锁的对象是方法的调用者；
2、调用者不同，它们之间用的不是同一个锁，相互之间没有关系。
示例4、两部手机、请问先打印邮件还是短信？
package com.interview.concurrent.lock.locakType;
import java.util.concurrent.TimeUnit;
/**
* @author yangxj
* @description 描述
* @date 2020/2/22 15:57
*/
public class MultiThreadUseMultiLock04 {
public static void main(String[] args){
// 两个对象，互不干预
Mobile4 mobile1 = new Mobile4();
Mobile4 mobile2 = new Mobile4();
new Thread(()->mobile1.sendEmail(),"A").start();
// 干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->mobile2.sendMS(),"B").start();
}
}
// 手机，发短信，发邮件
class Mobile4 {
/**
* @description:
* 被 synchronized 修饰的方法，锁的对象是方法的调用者；
* 调用者不同，它们之间用的不是同一个锁，相互之间没有关系。
*/
public synchronized void sendEmail() {
//这里设置一个干扰
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendEmail");
}
public synchronized void sendMS() {
System.out.println("sendMS");
}
}
5.5. Class锁：多个线程使用一个对象-顺序执行
被 synchronized 和 static 同时修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。
锁Class和锁对象的区别：
1、Class 锁 ，类模版，只有一个；
2、对象锁 ， 通过类模板可以new 多个对象。
如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
示例5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？
package com.interview.concurrent.lock.locakType;
import java.util.concurrent.TimeUnit;
/**
* @author yangxj
* @description 描述
* @date 2020/2/22 15:57
*/
public class MultiThreadUseOneObjectOneClassLock05 {
public static void main(String[] args){
Mobile5 mobile = new Mobile5();
new Thread(()->mobile.sendEmail(),"A").start();
// 干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->mobile.sendMS(),"B").start();
}
}
// 手机，发短信，发邮件
class Mobile5 {
/**
* @description:
*锁Class和锁对象的区别：
* 1、锁 Class，类模版，只有一个;
* 2、锁 对象，通过 类模板可以new 多个对象.
* 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
*被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。
*/
public synchronized static void sendEmail() {
//这里设置一个干扰
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendEmail");
}
public synchronized static void sendMS() {
System.out.println("sendMS");
}
}
5.6. Class锁：多个线程使用多个对象-顺序执行
被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。
Class锁是唯一的，所以多个对象使用的也是同一个Class锁。
示例6、两个静态同步方法，2部手机，请问先打印邮件还是短信？
package com.interview.concurrent.lock.locakType;
import java.util.concurrent.TimeUnit;
/**
* @author yangxj
* @description 描述
* @date 2020/2/22 15:57
*/
public class MultiThreadUseMultiObjectOneClassLock06 {
public static void main(String[] args){
Mobile6 mobile1 = new Mobile6();
Mobile6 mobile2 = new Mobile6();
new Thread(()->mobile1.sendEmail(),"A").start();
// 干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->mobile2.sendMS(),"B").start();
}
}
// 手机，发短信，发邮件
class Mobile6 {
/**
* @description:
*锁Class和锁对象的区别：
* 1、锁 Class，类模版，只有一个;
* 2、锁 对象，通过 类模板可以new 多个对象.
* 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
* 被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁
*/
public synchronized static void sendEmail() {
//这里设置一个干扰
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendEmail");
}
public synchronized static void sendMS() {
System.out.println("sendMS");
}
}
5.7. Class锁与对象锁：多个线程使用一个对象-随机执行
被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。
示例7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？
package com.interview.concurrent.lock.locakType;
import java.util.concurrent.TimeUnit;
/**
* @author yangxj
* @description 描述
* @date 2020/2/22 15:57
*/
public class MultiThreadUseOneObjectClassLockAndObjectLock07 {
public static void main(String[] args){
Mobile7 mobile = new Mobile7();
new Thread(()->mobile.sendEmail(),"A").start();
// 干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->mobile.sendMS(),"B").start();
}
}
// 手机，发短信，发邮件
class Mobile7 {
/**
* @description:
*锁Class和锁对象的区别：
* 1、锁 Class，类模版，只有一个;
* 2、锁 对象，通过 类模板可以new 多个对象.
* 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
* 被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁
*/
public synchronized static void sendEmail() {
//这里设置一个干扰
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendEmail");
}
/**
* @description:
* 普通同步锁：对象锁
*/
public synchronized void sendMS() {
System.out.println("sendMS");
}
}
5.8. Class锁与对象锁：多个线程使用多个对象-随机执行
被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。
示例8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？
package com.interview.concurrent.lock.locakType;
import java.util.concurrent.TimeUnit;
/**
* @author yangxj
* @description 描述
* @date 2020/2/22 15:57
*/
public class MultiThreadUseMultiObjectClassLockAndObjectLock08 {
public static void main(String[] args){
Mobile8 mobile1 = new Mobile8();
Mobile8 mobile2 = new Mobile8();
new Thread(()->mobile1.sendEmail(),"A").start();
// 干扰
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->mobile2.sendMS(),"B").start();
}
}
// 手机，发短信，发邮件
class Mobile8 {
/**
* @description:
*锁Class和锁对象的区别：
* 1、锁 Class，类模版，只有一个;
* 2、锁 对象，通过 类模板可以new 多个对象.
* 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
* 被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁
*/
public synchronized static void sendEmail() {
//这里设置一个干扰
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendEmail");
}
/**
* @description:
* 普通同步锁：对象锁
*/
public synchronized void sendMS() {
System.out.println("sendMS");
}
}
小结
new this 本身的这个对象，调用者
static class 类模板，保证唯一！
一个对象中有多个 synchronized 方法，某个时刻内只要有一个线程去访问 synchronized 方法了就会被加锁，独立公共厕所！其他线程就会阻塞！
加了一个普通方法后 ，两个对象，无关先后，一个有锁，一个没锁！情况会变化！
换成静态同步方法，情况会变化！ CLASS ，所有静态同步方法的锁唯一 ， 对象实例class 本身！