如何判断锁的是谁!理解锁!锁到底锁的是谁!
对象、class 。
1.前两个问题
java
package com.kuang.lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁 ,就是关于锁的8个问题
* 1、标准情况下,两个线程先打印 发短信还是打电话? 1/发短信 2/打电话
* 2、sendSms 延迟4秒,两个线程先打印 发短信还是 打电话 ? 1/发短信 2/打电话
*/
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
//锁的存在,才导致,它先执行。面试的适合,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
new Thread(()->{
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"B").start();
}
}
class Phone{
//synchronized 锁的对象是方法的调用者! phone
//两个方法用的是同一个锁,谁先拿到谁执行!
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendSms");
}
public synchronized void call(){
System.out.println("call");
}
}
2.3-4问题
java
package com.kuang.lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁 ,就是关于锁的8个问题
*
* 3.增加了一个普通方法! 发短信还是Hello? 是hello.
* 4. 两个对象,两个同步方法! 发短信还是打电话? 是打电话
*/
public class Test2 {
public static void main(String[] args) {
//两个对象 ,两个调用者 ,两把锁!
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
//锁的存在,才导致,它先执行。面试的适合,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
new Thread(()->{
phone1.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.hello();
},"B").start();
}
}
class Phone2{
//synchronized 锁的对象是方法的调用者! phone
//两个方法用的是同一个锁,谁先拿到谁执行!
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendSms");
}
public synchronized void call(){
System.out.println("call");
}
//这里没有锁!不是同步方法,不受锁的影响!
public void hello(){
System.out.println("hello");
}
}
3.5-6
java
package com.kuang.lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁 ,就是关于锁的8个问题
*
* 5.增加两个静态同步方法,只有一个对象,先打印,发短信?打电话? 打印发短信!!因为锁的都是同一个class对象
* 6.增加两个对象,两个静态的同步方法,先打印,发短信?打电话? 打印发短信!! 因为锁的都是同一个class对象,与对象本身无关
*/
public class Test3 {
public static void main(String[] args) {
//两个对象的class 类模板只有一个,static,锁的是class
Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
//锁的存在,才导致,它先执行。面试的适合,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
new Thread(()->{
phone1.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
//Phone3唯一的一个Class对象
class Phone3{
//synchronized 锁的对象是方法的调用者! phone
//两个方法用的是同一个锁,谁先拿到谁执行!
//static 静态方法
//类一加载就有了!锁的Class 锁的是模板
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendSms");
}
public static synchronized void call(){
System.out.println("call");
}
}
4.第7个问题
java
package com.kuang.lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁 ,就是关于锁的8个问题
*
* 7. 1个静态的同步方法,1个普通的同步方法,1个对象 ,先打印发短信?还是打电话? 打电话,因为锁的不是同一个东西,而打电话的睡眠时间少,所以打电话先打印
*
*/
public class Test4 {
public static void main(String[] args) {
//两个对象的class 类模板只有一个,static,锁的是class
Phone4 phone = new Phone4();
//锁的存在,才导致,它先执行。面试的适合,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
new Thread(()->{
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"B").start();
}
}
//Phone3唯一的一个Class对象
class Phone4{
//静态的同步方法
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendSms");
}
//普通的同步方法
public synchronized void call(){
System.out.println("call");
}
}
5.8-9个问题
java
package com.kuang.lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁 ,就是关于锁的8个问题
*
* 8. 1个静态的同步方法,1个普通的同步方法,2个对象 ,先打印发短信?还是打电话? 打电话,因为锁的不是同一个东西,而打电话的睡眠时间少,所以打电话先打印
* 9. 如何让静态方法与 普通方法实现同步,用 synchronized 在普通方法里 锁住 字节码对象,就可以实现同步 然后就是发短信先打印了
*
*/
public class Test5 {
public static void main(String[] args) {
//两个对象的class 类模板只有一个,static,锁的是class
Phone5 phone1 = new Phone5();
Phone5 phone2 = new Phone5();
//锁的存在,才导致,它先执行。面试的时候,不能说是因为他先被调用,而是它先抢到了锁,所以它先打印!
new Thread(()->{
phone1.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
//Phone3唯一的一个Class对象
class Phone5{
//静态的同步方法
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendSms");
}
//普通的同步方法
public void call(){
synchronized(Phone5.class){
System.out.println("call");
}
}
}