多线程锁-8锁案例编码演示
3.2 通过8种情况演示锁运行案例，看看锁到底是什么
3.2.1 锁相关的8种案例演示code
1.标准访问ab两个线程，请问先打印邮件还是短信？
package com.nanjing.gulimall.zhouyimo.test;
import java.util.concurrent.TimeUnit;
/**
* @author zhou
*/
//资源类，口诀：线程操作资源类
class Phone {
public synchronized void sendEmail() {
System.out.println("------sendEmail");
}
public synchronized void sendSMS() {
System.out.println("------sendSMS");
}
}
public class Lock8Demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
phone.sendEmail();
},"A").start();
//暂停毫秒，保证A线程先启动
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone.sendSMS();
}, "B").start();
//1 标准访问ab两个线程，请问先打印邮件还是短信？
/*------sendEmail
------sendSMS*/
//先邮件，后短信 共用一个对象锁
}
}
2. sendEmail钟加入暂停3秒钟，请问先打印邮件还是短信？
package com.nanjing.gulimall.zhouyimo.test;
import java.util.concurrent.TimeUnit;
/**
* @author zhou
*/
//资源类，口诀：线程操作资源类
class Phone {
public synchronized void sendEmail() {
//暂停3秒钟
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------sendEmail");
}
public synchronized void sendSMS() {
System.out.println("------sendSMS");
}
}
public class Lock8Demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
phone.sendEmail();
},"A").start();
//暂停毫秒，保证A线程先启动
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone.sendSMS();
}, "B").start();
//2. sendEmail钟加入暂停3秒钟，请问先打印邮件还是短信？
/*------sendEmail
------sendSMS*/
//依然是先邮件，后短信 共用一个对象锁
}
}
3. 添加一个普通的hello方法，请问先打印普通方法还是邮件？
package com.nanjing.gulimall.zhouyimo.test;
import java.util.concurrent.TimeUnit;
/**
* @author zhou
*/
//资源类，口诀：线程操作资源类
class Phone {
public synchronized void sendEmail() {
//暂停3秒钟
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------sendEmail");
}
public synchronized void sendSMS() {
System.out.println("------sendSMS");
}
public void hello(){
System.out.println("------hello");
}
}
public class Lock8Demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
phone.sendEmail();
},"A").start();
//暂停200毫秒，保证A线程先启动
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() ->{
phone.hello();
},"B").start();
//3. 添加一个普通的hello方法，请问先打印普通方法还是邮件？
/*
------hello
------sendEmail*/
//程序执行在sendEmail()中锁了并在方法中睡3秒，外部在睡200毫秒后调用hello()，因为无锁因此直接执行
}
}
4. 有两部手机，请问先打印邮件还是短信？
package com.nanjing.gulimall.zhouyimo.test;
import java.util.concurrent.TimeUnit;
/**
* @author zhou
*/
//资源类，口诀：线程操作资源类
class Phone {
public synchronized void sendEmail() {
//暂停3秒钟
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------sendEmail");
}
public synchronized void sendSMS() {
System.out.println("------sendSMS");
}
}
public class Lock8Demo {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone2 = new Phone();
new Thread(() -> {
phone.sendEmail();
},"A").start();
//暂停200毫秒，保证A线程先启动
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() ->{
phone2.sendSMS();
},"B").start();
//4. 有两部手机，请问先打印邮件还是短信？
/*
------sendSMS
------sendEmail*/
//程序调用sendEmail()时锁住phone，外部睡1秒后调用sendSMS()时锁phone2，互不影响
}
}
5. 有两个静态同步方法，一步手机， 请问先打印邮件还是短信？
package com.nanjing.gulimall.zhouyimo.test;
import java.util.concurrent.TimeUnit;
/**
* @author zhou
*/
//资源类，口诀：线程操作资源类
class Phone {
public static synchronized void sendEmail() {
//暂停3秒钟
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------sendEmail");
}
public static synchronized void sendSMS() {
System.out.println("------sendSMS");
}
}
public class Lock8Demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
phone.sendEmail();
},"A").start();
//暂停200毫秒，保证A线程先启动
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() ->{
phone.sendSMS();
},"B").start();
//5. 有两个静态同步方法，一步手机， 请问先打印邮件还是短信？
/*
------sendEmail
------sendSMS*/
//这里多了静态static，因此此时锁的东西改变了，sendEmail()和sendSMS()都是锁的Phone这个class，
//程序在执行sendEmail()时锁住Phone class，睡200毫秒后调用sendSMS()，sendSMS()等待sendEmail()内睡完释放锁后再执行
}
}
6. 有两个静态同步方法，两部手机， 请问先打印邮件还是短信？
package com.nanjing.gulimall.zhouyimo.test;
import java.util.concurrent.TimeUnit;
/**
* @author zhou
*/
//资源类，口诀：线程操作资源类
class Phone {
public static synchronized void sendEmail() {
//暂停3秒钟
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------sendEmail");
}
public static synchronized void sendSMS() {
System.out.println("------sendSMS");
}
}
public class Lock8Demo {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone2 = new Phone();
new Thread(() -> {
phone.sendEmail();
},"A").start();
//暂停200毫秒，保证A线程先启动
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() ->{
phone2.sendSMS();
},"B").start();
//6. 有两个静态同步方法，两部手机， 请问先打印邮件还是短信？
/*
------sendEmail
------sendSMS*/
//要注意的是，不管现在new结果对象，调用方法后锁的都是Phone class，sendSMS()会被sendEmail()阻塞
}
}
7. 有一个静态同步方法 一个普通同步方法，1部手机，请问先打印邮件还是短信？
package com.nanjing.gulimall.zhouyimo.test;
import java.util.concurrent.TimeUnit;
/**
* @author zhou
*/
//资源类，口诀：线程操作资源类
class Phone {
public static synchronized void sendEmail() {
//暂停3秒钟
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------sendEmail");
}
public synchronized void sendSMS() {
System.out.println("------sendSMS");
}
}
public class Lock8Demo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
phone.sendEmail();
},"A").start();
//暂停200毫秒，保证A线程先启动
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() ->{
phone.sendSMS();
},"B").start();
//7. 有一个静态同步方法 一个普通同步方法，1部手机，请问先打印邮件还是短信？
/*
------sendSMS
------sendEmail*/
//同样只要确认锁的是不是一个东西就知道会不会阻塞，调用sendEmail()时阻塞的是Phone class，调用sendSMS()时阻塞的是phone
}
}
8. 有一个静态同步方法，一个普通同步方法，两部手机，请问先打印邮件还是短信？
package com.nanjing.gulimall.zhouyimo.test;
import java.util.concurrent.TimeUnit;
/**
* @author zhou
*/
//资源类，口诀：线程操作资源类
class Phone {
public static synchronized void sendEmail() {
//暂停3秒钟
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------sendEmail");
}
public synchronized void sendSMS() {
System.out.println("------sendSMS");
}
}
public class Lock8Demo {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone2 = new Phone();
new Thread(() -> {
phone.sendEmail();
},"A").start();
//暂停200毫秒，保证A线程先启动
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() ->{
phone2.sendSMS();
},"B").start();
//8. 有一个静态同步方法，一个普通同步方法，两部手机，请问先打印邮件还是短信？
/*
------sendSMS
------sendEmail*/
//解题跟7一致，调用sendEmail()时阻塞的是Phone class，调用sendSMS()时阻塞的是phone2，一个类锁一个对象锁
}
}
分析：
结论：
1.对于普通同步方法，锁的是当前实例对象，通常指this，所有的同步方法用的
都是同一把锁--->实例对象本身
2.对于静态同步方法，锁的时当前类的Class对象
3.对于同步方法块，锁的时synchronized括号内的对象
多线程8锁问题-CSDN博客
线程八锁-CSDN博客