问题一,二
//1.标准情况下,两个线程先打印发短信还是打电话 1/send 2/call-----》send
//2.send延迟4秒,两个线程先打印发短信还是打电话 1/send 2/call-----》先等4秒再send
//回答:因为有锁的存在,synchronized锁的对象是方法的调用者,因为再这个方法中对象只有一个phone,
// 也就是同一把锁,所以谁先拿到锁谁就先执行
public class Test1 {
public static void main(String[] args) {
Phone phone=new Phone();
new Thread(()->{phone.send();},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
new Thread(()->{phone.call();},"B").start();
}
}
class Phone{
public synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("send");
}
public synchronized void call(){
System.out.println("call");
}
}
问题三
//3.如下两个线程是打印send(synchronized方法)还是hello(普通方法)--》1s后打印hello 4s后打印了send
//回答,hello没有锁不受锁的影响
public class Test2 {
public static void main(String[] args) {
Phone2 phone=new Phone2();
new Thread(()->{phone.send();},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
new Thread(()->{phone.hello();},"B").start();
}
}
class Phone2{
public synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("send");
}
public void hello(){
System.out.println("hello");
}
}
问题四:
//4.两个对象,两个同步方法,先send还是先call --》先call因为send睡眠了4s
//回答,hello没有锁不受锁的影响
public class Test2 {
public static void main(String[] args) {
Phone2 phone1=new Phone2();
Phone2 phone2=new Phone2();
new Thread(()->{phone1.send();},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
new Thread(()->{phone2.call();},"B").start();
}
}
class Phone2{
public synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("send");
}
public synchronized void call(){
System.out.println("call");
}
}
问题五,六
//5.现在是一个对象,但是两个方法都变成了静态方法先send还是先call? 等4秒先send后call
//6. 如果现在是两个对象,两个静态方法,先send还是先call? 等4秒先send后call
//回答,于之前的情况来说对于静态方法,他的锁不是对象而是Class,只有唯一的一个class对象,与对象其实已经无关了
public class Test3 {
public static void main(String[] args) {
Phone3 phone1=new Phone3();
Phone3 phone2=new Phone3();
new Thread(()->{phone1.send();},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
new Thread(()->{phone2.call();},"B").start();
}
}
class Phone3{
public static synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("send");
}
public static synchronized void call(){
System.out.println("call");
}
}
问题七,八(两个对象也是打电话,两把锁是一个class模板一个对象和两个对象无关)
//对于一个普通同步方法call和一个静态同步方法send,只使用一个对象来调用,先send还是先call?
// 先call,再send。两个方法使用的是两把锁,call不需要等待所以比send快
public class Test4 {
public static void main(String[] args) {
Phone4 phone1=new Phone4();
new Thread(()->{phone1.send();},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
new Thread(()->{phone1.call();},"B").start();
}
}
class Phone4{
public static synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("send");
}
public synchronized void call(){
System.out.println("call");
}
}