JUC高并发编程(07) -- 多线程锁 -- 演示锁的八种情况
JUC高并发编程
六、多线程锁
6.1）演示锁的八种情况
6.1.1）标准访问
代码如下：
class Phone {
// 打印短信
public synchronized void sendSMS() throws Exception {
System.out.println("------sendSMS");
}
// 打印邮件
public synchronized void sendEmail() throws Exception {
System.out.println("------sendEmail");
}
}
public class Lock_8 {
public static void main(String[] args) throws Exception {
Phone phone = new Phone();
// 创建线程AA
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "AA").start();
Thread.sleep(100);
// 创建线程BB
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "BB").start();
}
}输出：标准访问，先打印短后打印邮件
------sendSMS
------sendEmail
6.1.2）停4秒在短信方法内
代码如下：
class Phone {
// 打印短信
public synchronized void sendSMS() throws Exception {
//停留4秒
TimeUnit.SECONDS.sleep(4);
System.out.println("------sendSMS");
}
// 打印邮件
public synchronized void sendEmail() throws Exception {
System.out.println("------sendEmail");
}
}
public class Lock_8 {
public static void main(String[] args) throws Exception {
Phone phone = new Phone();
// 创建线程AA
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "AA").start();
Thread.sleep(100);
// 创建线程BB
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "BB").start();
}
}输出：停4秒在短信方法内，先打印短后打印邮件
------sendSMS
------sendEmail
说明：上述两种情况输出结果相同，表示添加 synchronized 关键字后加锁的是当前使用的对象(即phone)，即先执行phone.sendSMS()再执行phone.sendEmail()。
6.1.3）新增普通方法
代码如下：
class Phone {
// 打印短信
public synchronized void sendSMS() throws Exception {
//停留4秒
TimeUnit.SECONDS.sleep(4);
System.out.println("------sendSMS");
}
// 打印邮件
public synchronized void sendEmail() throws Exception {
System.out.println("------sendEmail");
}
// 普通方法
public void getHello() {
System.out.println("------getHello");
}
}
public class Lock_8 {
public static void main(String[] args) throws Exception {
Phone phone = new Phone();
// 创建线程AA
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "AA").start();
Thread.sleep(100);
// 创建线程BB
new Thread(() -> {
try {
phone.getHello();
} catch (Exception e) {
e.printStackTrace();
}
}, "BB").start();
}
}输出：新增普通的hello方法，先执行普通hello方法再打印短信
------getHello
------sendSMS
说明：上述输出结果表示，不添加 synchronized关键字的普通方法先执行，添加synchronized关键字的方法后执行，即先执行phone.getHello()再执行phone.sendSMS()。
6.1.4）两部手机
代码如下：
class Phone {
// 打印短信
public synchronized void sendSMS() throws Exception {
//停留4秒
TimeUnit.SECONDS.sleep(4);
System.out.println("------sendSMS");
}
// 打印邮件
public synchronized void sendEmail() throws Exception {
System.out.println("------sendEmail");
}
}
public class Lock_8 {
public static void main(String[] args) throws Exception {
Phone phone = new Phone();
Phone phone2 = new Phone();
// 创建线程AA
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "AA").start();
Thread.sleep(100);
// 创建线程BB
new Thread(() -> {
try {
phone2.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "BB").start();
}
}输出：现在有两部手机，先打印邮件再打印短信
------sendEmail
-----sendSMS
说明：上述输出结果表示添加 synchronized 关键字后加锁的是当前使用的对象(即phone)，现在出现了2个对象所以加锁失效，因为实际上是加了2把锁，并不是同一把锁，即先执行phone2.sendEmail()再执行phone.sendSMS()。
6.1.5）两个静态同步方法，1部手机
代码如下：
class Phone {
// 打印短信
public static synchronized void sendSMS() throws Exception {
//停留4秒
TimeUnit.SECONDS.sleep(4);
System.out.println("------sendSMS");
}
// 打印邮件
public static synchronized void sendEmail() throws Exception {
System.out.println("------sendEmail");
}
}
public class Lock_8 {
public static void main(String[] args) throws Exception {
Phone phone = new Phone();
// 创建线程AA
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "AA").start();
Thread.sleep(100);
// 创建线程BB
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "BB").start();
}
}输出：两个静态同步方法，1部手机，先打印短信再打印邮件
------sendSMS
------sendEmail
6.1.6）两个静态同步方法，2部手机
代码如下：
class Phone {
// 打印短信
public static synchronized void sendSMS() throws Exception {
//停留4秒
TimeUnit.SECONDS.sleep(4);
System.out.println("------sendSMS");
}
// 打印邮件
public static synchronized void sendEmail() throws Exception {
System.out.println("------sendEmail");
}
}
public class Lock_8 {
public static void main(String[] args) throws Exception {
Phone phone = new Phone();
Phone phone2 = new Phone();
// 创建线程AA
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "AA").start();
Thread.sleep(100);
// 创建线程BB
new Thread(() -> {
try {
phone2.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "BB").start();
}
}输出：两个静态同步方法，2部手机，先打印短信再打印邮件
------sendSMS
------sendEmail
说明：上述两种情况输出结果相同，表示添加 static synchronized 关键字后加锁的是当前的字节码对象(即 class Phone )而不是实例对象(即 Phone )，相当于全局加锁了，即先执行phone2.sendEmail()再执行phone.sendSMS()。
6.1.7）1个静态同步方法,1个普通同步方法，1部手机
代码如下：
class Phone {
// 打印短信
public static synchronized void sendSMS() throws Exception {
//停留4秒
TimeUnit.SECONDS.sleep(4);
System.out.println("------sendSMS");
}
// 打印邮件
public synchronized void sendEmail() throws Exception {
System.out.println("------sendEmail");
}
}
public class Lock_8 {
public static void main(String[] args) throws Exception {
Phone phone = new Phone();
// 创建线程AA
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "AA").start();
Thread.sleep(100);
// 创建线程BB
new Thread(() -> {
try {
phone.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "BB").start();
}
}输出：1个静态同步方法,1个普通同步方法，1部手机，先打印邮件再打印短信
------sendEmail
------sendSMS
6.1.8）1个静态同步方法,1个普通同步方法，2部手机
代码如下：
class Phone {
// 打印短信
public static synchronized void sendSMS() throws Exception {
//停留4秒
TimeUnit.SECONDS.sleep(4);
System.out.println("------sendSMS");
}
// 打印邮件
public synchronized void sendEmail() throws Exception {
System.out.println("------sendEmail");
}
}
public class Lock_8 {
public static void main(String[] args) throws Exception {
Phone phone = new Phone();
Phone phone2 = new Phone();
// 创建线程AA
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "AA").start();
Thread.sleep(100);
// 创建线程BB
new Thread(() -> {
try {
phone2.sendEmail();
} catch (Exception e) {
e.printStackTrace();
}
}, "BB").start();
}
}输出：1个静态同步方法,1个普通同步方法，2部手机，先打印邮件再打印短信
------sendEmail
------sendSMS
说明：上述两种情况输出结果相同，表示静态同步方法和普通同步方法的加锁对象不同，还是2把锁，所以锁实际是失效的，即先执行phone2.sendEmail()再执行phone.sendSMS()。
6.1.9）小结
一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了， 其它的线程都只能等待，就是说，某一个时刻内只能有唯一一个线程去访问这些 synchronized方法；
锁的是当前this对象，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized方法，加入普通方法后发现和同步锁无关；
换成两个对象后，不是同一把锁了，锁实际上是无效的。
synchronized实现同步的基础：Java中的每一个对象都可以作为锁，具体表现为以下3种形式：
-
对于普通同步方法，锁是当前实例对象；
-
对于静态同步方法，锁是当前类的Class对象；
-
对于同步方法块，锁是Synchonized括号里配置的对象
当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁；也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步 法必须等待获取锁的方法释放锁后才能获取锁， 可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁， 所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象， 以静态同步方法与非静态同步方法之间是不会有竞态条件的。
但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间还是不同的实例对象的静态同 步方法之间，只要它们同一个类的实例对象！