线程八锁

线程八锁

情况一

@Slf4j(topic = "c.Number") class Number { public synchronized void a() { log.debug("1"); } public synchronized void b() { log.debug("2"); } } public class Main { public static void main(String[] args) { Number number = new Number(); new Thread(() -> {number.a();}).start(); new Thread(() -> {number.b();}).start(); } }

在这种情况里$synchronized$锁住的都是$this$对象，即$number$，因此这个题执行时，结果为$1,2$或者$2,1$且大概率是$1,2$

情况二

@Slf4j(topic = "c.Number") class Number { public synchronized void a() { log.debug("1"); } public synchronized void b() { sleep(1); log.debug("2"); } } public class Main { public static void main(String[] args) { Number number = new Number(); new Thread(() -> {number.a();}).start(); new Thread(() -> {number.b();}).start(); } }

这种情况与第一种相同，只是多了一个睡眠，因此结果为，延迟一秒打印$2,1$或者$1$延迟一秒$2$

情况三

@Slf4j(topic = "c.Number") class Number { public synchronized void a() { log.debug("1"); } public synchronized void b() throws InterruptedException { Thread.sleep(1000); log.debug("2"); } public void c() { log.debug("3"); } } public class Main { public static void main(String[] args) { Number number = new Number(); new Thread(() -> {number.a();}).start(); new Thread(() -> {number.b();}).start(); new Thread(() -> {number.c();}).start(); } }

这种情况里多了一个方法$c()$，但是他没有被对象锁限制，因此它一定打印，所以情况有打印$1,3$一秒后打印$2$打印$3,1$一秒后打印$2$打印3一秒后打印$2, 1$

情况四

@Slf4j(topic = "c.Number") class Number { public synchronized void a() { log.debug("1"); } public synchronized void b() throws InterruptedException { Thread.sleep(1000); log.debug("2"); } } public class Main { public static void main(String[] args) { Number number1 = new Number(); Number number2 = new Number(); new Thread(() -> {number1.a();}).start(); new Thread(() -> {number2.b();}).start(); } }

这种情况下，是两个不同的对象调用的方法，因此压根没有互斥，所以一定是先打印$1$一秒后打印$2$

情况五

@Slf4j(topic = "c.Number") class Number { public synchronized void a() { log.debug("1"); } public static synchronized void b() throws InterruptedException { Thread.sleep(1000); log.debug("2"); } } public class Main { public static void main(String[] args) { Number number1 = new Number(); new Thread(() -> {number1.a();}).start(); new Thread(() -> {number1.b();}).start(); } }

这里方法$b$被$static$修饰，因此他锁住的实际上是类对象，所以这两个也不互斥，所以一定是先打印$1$，一秒后再打印$2$

情况六

@Slf4j(topic = "c.Number") class Number { public static synchronized void a() { log.debug("1"); } public static synchronized void b() throws InterruptedException { Thread.sleep(1000); log.debug("2"); } } public class Main { public static void main(String[] args) { Number number1 = new Number(); new Thread(() -> {number1.a();}).start(); new Thread(() -> {number1.b();}).start(); } }

这时这两个方法都被$static$关键字修饰，所以实际上锁住的都是类对象，因此他们是互斥的，所以打印结果为$1$一秒后打印$2$或者一秒后$21$

情况七

@Slf4j(topic = "c.Number") class Number { public synchronized void a() { log.debug("1"); } public static synchronized void b() throws InterruptedException { Thread.sleep(1000); log.debug("2"); } } public class Main { public static void main(String[] args) { Number number1 = new Number(); Number number2 = new Number(); new Thread(() -> {number1.a();}).start(); new Thread(() -> {number2.b();}).start(); } }

这种情况下一个锁住的是类对象，一个锁住的是$number1$对象，因此是不互斥的，结果为$1$一秒后$2$

情况八

@Slf4j(topic = "c.Number") class Number { public static synchronized void a() { log.debug("1"); } public static synchronized void b() throws InterruptedException { Thread.sleep(1000); log.debug("2"); } } public class Main { public static void main(String[] args) { Number number1 = new Number(); Number number2 = new Number(); new Thread(() -> {number1.a();}).start(); new Thread(() -> {number2.b();}).start(); } }

这种情况下，虽然调用对象不同，但实际上两个方法都是静态的，锁住的都是类对象，因此是互斥的，带引结果为$1$一秒后打印$2$或者一秒后打印$21$

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。