4. 8锁现象
- 关于锁的8个问题
范例1：
package pers.vincent.matrix.subject.lock8;
import java.util.concurrent.TimeUnit;
public class Test1 {
public static void main(String[] args) throws InterruptedException {
Phone phone = new Phone();
new Thread(()->{
try {
phone.sendSms();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone.phone();
}).start();
}
}
/**
* 1. synchronized 锁的是方法的调用者
* 此时 两个方法的调用者都是phone, 谁先获得锁谁先执行
*/
class Phone{
public synchronized void sendSms() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("发短信");
}
public synchronized void phone(){
System.out.println("打电话");
}
}
范例2：
package pers.vincent.matrix.subject.lock8;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) throws InterruptedException {
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
new Thread(()->{
try {
phone1.sendSms();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone2.phone();
}).start();
}
}
/**
* 1. Synchronized 锁的是方法的调用者
* 2. 此时两个方法由不同的调用者，归为不同的锁。打电话 没有时间等待
*/
class Phone2{
public synchronized void sendSms() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("发短信");
}
public synchronized void phone(){
System.out.println("打电话");
}
}
范例3：
package pers.vincent.matrix.subject.lock8;
import java.util.concurrent.TimeUnit;
public class Test3 {
public static void main(String[] args) throws InterruptedException {
Phone3 phone1 = new Phone3();
new Thread(()->{
try {
phone1.sendSms();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone1.call();
}).start();
}
}
/**
* 1. Synchronized 锁的是方法的调用者
* call() 没有 synchronized 修饰 没有锁的概念，先执行
*/
class Phone3{
public synchronized void sendSms() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("发短信");
}
public synchronized void phone(){
System.out.println("打电话");
}
public void call(){
System.out.println("我要打电话给");
}
}
范例4：
package pers.vincent.matrix.subject.lock8;
import java.util.concurrent.TimeUnit;
public class Test4 {
public static void main(String[] args) throws InterruptedException {
Phone4 phone1 = new Phone4();
new Thread(()->{
try {
phone1.sendSms();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone1.phone();
}).start();
}
}
/**
* 1. Synchronized 锁的是方法的调用者
* static 修饰符，说明方法为静态方法 类加载的时候就初始化了。它锁的是 类的 Class
* 两个方法的调用者一致，且都有 static 修饰符；则 谁先拿到谁执行： 发短信
*/
class Phone4{
public static synchronized void sendSms() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("发短信");
}
public static synchronized void phone(){
System.out.println("打电话");
}
}
范例5：
package pers.vincent.matrix.subject.lock8;
import java.util.concurrent.TimeUnit;
public class Test5 {
public static void main(String[] args) throws InterruptedException {
Phone5 phone1 = new Phone5();
new Thread(()->{
try {
phone1.sendSms();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone1.phone();
}).start();
}
}
/**
* 1. Synchronized 锁的是方法的调用者
* static 修饰符，说明方法为静态方法 类加载的时候就初始化了。它锁的是 类的 Class
*
* 此时 sendSms 锁的是 Class, 而phone 锁的方法的调用者 phone1;
*
* 他们属于不同的锁，没有先后和等待：打电话
*/
class Phone5{
public static synchronized void sendSms() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("发短信");
}
public synchronized void phone(){
System.out.println("打电话");
}
}
范例6：
package pers.vincent.matrix.subject.lock8;
import java.util.concurrent.TimeUnit;
public class Test6 {
public static void main(String[] args) throws InterruptedException {
Phone6 phone1 = new Phone6();
Phone6 phone2 = new Phone6();
new Thread(()->{
try {
phone1.sendSms();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone2.phone();
}).start();
}
}
/**
* 1. Synchronized 锁的是方法的调用者
* static 修饰符，说明方法为静态方法 类加载的时候就初始化了。它锁的是 类的 Class
*
* 此时两个方法的锁的是同一个 Class ： 发短信
*/
class Phone6{
public static synchronized void sendSms() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("发短信");
}
public static synchronized void phone(){
System.out.println("打电话");
}
}
范例7：
package pers.vincent.matrix.subject.lock8;
import java.util.concurrent.TimeUnit;
public class Test7 {
public static void main(String[] args) throws InterruptedException {
Phone7 phone1 = new Phone7();
new Thread(()->{
try {
phone1.sendSms();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone1.phone();
}).start();
}
}
/**
* 1. Synchronized 锁的是方法的调用者
* static 修饰符，说明方法为静态方法 类加载的时候就初始化了。它锁的是 类的 Class
*
* 此时sendSms 锁的是Class phone 锁的方法的调用者
* 打电话
*/
class Phone7{
public static synchronized void sendSms() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("发短信");
}
public synchronized void phone(){
System.out.println("打电话");
}
}
范例8：
package pers.vincent.matrix.subject.lock8;
import java.util.concurrent.TimeUnit;
public class Test8 {
public static void main(String[] args) throws InterruptedException {
Phone8 phone1 = new Phone8();
Phone8 phone2 = new Phone8();
new Thread(()->{
try {
phone1.sendSms();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
phone2.phone();
}).start();
}
}
/**
* 1. Synchronized 锁的是方法的调用者
*
* 还是两把不同的锁，
*
* 打电话
*/
class Phone8{
public static synchronized void sendSms() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("发短信");
}
public synchronized void phone(){
System.out.println("打电话");
}
}
浙公网安备 33010602011771号