问题一:下面代码先执行打电话还是发短信 发短信
public class A {
public static void main(String[] args) throws InterruptedException {
Phone phone = new Phone();
// 锁的存在
new Thread(()->{
try {
phone.sendmsg();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
// 休息1s
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone.call(); },"B").start();
}
}
@SuppressWarnings("all")
class Phone {
// synchronized锁的对象是方法的调用者
// 两个方法用的是同一个锁,谁先拿到谁执行
public synchronized void sendmsg() throws InterruptedException {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
}
问题二---如果变为两个对象,下面代码先执行打电话还是发短信? 打电话
public class A {
public static void main(String[] args) throws InterruptedException {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
// 锁的存在
new Thread(()->{
try {
phone1.sendmsg();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
// 休息1s
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone2.call(); },"B").start();
}
}
@SuppressWarnings("all")
class Phone {
// synchronized锁的对象是方法的调用者
// 两个方法用的是同一个锁,谁先拿到谁执行
public synchronized void sendmsg() throws InterruptedException {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
}
问题三---增加普通方法,先打印发短信还是hello?
public class B {
public static void main(String[] args) throws InterruptedException {
Phone2 phone = new Phone2();
new Thread(()->{
try {
phone.sendmsg();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
// 休息1s
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone.hello(); },"B").start();
}
}
@SuppressWarnings("all")
class Phone2 {
// synchronized锁的对象是方法的调用者
// 两个方法用的是同一个锁,谁先拿到谁执行
public synchronized void sendmsg() throws InterruptedException {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
// 这里没有锁,不是同步方法,不受锁的影响
public void hello() {
System.out.println("hello");
}
}
问题四---用不同对象去调用发短信和hello方法,执行结果?
public class B {
public static void main(String[] args) throws InterruptedException {
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
new Thread(()->{
try {
phone1.sendmsg();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
// 休息1s
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone2.hello(); },"B").start();
}
}
@SuppressWarnings("all")
class Phone2 {
public synchronized void sendmsg() throws InterruptedException {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
// 这里没有锁,不是同步方法,不受锁的影响
public void hello() {
System.out.println("hello");
}
}
解释同上
问题5---当加了static关键字之后,执行结果是怎样的?
public class C {
public static void main(String[] args) throws InterruptedException {
Phone3 phone = new Phone3();
new Thread(()->{
try {
phone.sendmsg();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
// 休息1s
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone.call(); },"B").start();
}
}
@SuppressWarnings("all")
// phone3只有唯一的一个class对象 phone3.class(全局唯一)
class Phone3 {
// synchronized锁的对象是方法的调用者
// 两个方法用的是同一个锁,谁先拿到谁执行
// static 静态方法,类一加载就有了,class 模板
// 此时锁的就是class
public static synchronized void sendmsg() throws InterruptedException {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短信");
}
public static synchronized void call() {
System.out.println("打电话");
}
}
问题6---当加了static关键字来修饰之后,用两个不同对象来调用,执行结果又是怎样?
public class C {
public static void main(String[] args) throws InterruptedException {
// 两个对象,但此时锁的是class,不关对象事。
// 两个对象的class类模板只有一个
Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
new Thread(()->{
try {
phone1.sendmsg();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
// 休息1s
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone2.call(); },"B").start();
}
}
@SuppressWarnings("all")
// phone3只有唯一的一个class对象 phone3.class(全局唯一)
class Phone3 {
// synchronized锁的对象是方法的调用者
// 两个方法用的是同一个锁,谁先拿到谁执行
// static 静态方法,类一加载就有了,class 模板
// 此时锁的就是class
public static synchronized void sendmsg() throws InterruptedException {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短信");
}
public static synchronized void call() {
System.out.println("打电话");
}
}
问题7--普通同步方法和静态同步方法放一起,执行顺序是怎样的?
public class D {
public static void main(String[] args) throws InterruptedException {
Phone4 phone = new Phone4();
new Thread(()->{
try {
phone.sendmsg();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
// 休息1s
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone.call(); },"B").start();
}
}
@SuppressWarnings("all")
// phone3只有唯一的一个class对象 phone3.class(全局唯一)
class Phone4 {
// 静态同步方法
public static synchronized void sendmsg() throws InterruptedException {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短信");
}
// 普通同步方法
public synchronized void call() {
System.out.println("打电话");
}
}
分析:
问题8:两个不同对象来调用,结果又是怎样?
public class D {
public static void main(String[] args) throwsphone1 = newphone2 = new Phone4();
new Thread(()->{
try {
phone1.sendmsg();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
// 休息1s
TimeUnit.SECONDS.sleep(1);
new Thread(()->{ phone2.call(); },"B").start();
}
}
@SuppressWarnings("all")
// phone3只有唯一的一个class对象 phone3.class(全局唯一)
class Phone4 {
// 静态同步方法
public static synchronized void sendmsg() throws InterruptedException {
TimeUnit.SECONDS.sleep(4);
System.out.println("发短信");
}
// 普通同步方法
public synchronized void call() {
System.out.println("打电话");
}
}
结果:
标签:synchronized,void,InterruptedException,public,问题,关于,new,class From: https://blog.51cto.com/u_15810109/5718739