devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

多线程与并发 - 多线程访问同步方法的7种情况

作者：2023面试高手 | 2024-03-28 17:36:32

赞

踩

多线程与并发 - 多线程访问同步方法的7种情况

不啰嗦，我们直接开始！

1、两个线程同时访问一个对象的同步方法

代码：

  1. public class SynchronizedObjectMethod implements Runnable {
  2.     static SynchronizedObjectMethod instance = new SynchronizedObjectMethod();
  3.  
  4.     @Override
  5.     public void run() {
  6.         method();
  7.     }
  8.  
  9.     public synchronized void method() {
  10.         System.out.println("对象锁的方法修饰符形式，我叫：" + Thread.currentThread().getName());
  11.         try {
  12.             System.out.println(Thread.currentThread().getName() + " 休眠3秒");
  13.             Thread.sleep(3000);
  14.         } catch (InterruptedException e) {
  15.             e.printStackTrace();
  16.         }
  17.         System.out.println(Thread.currentThread().getName() + "运行结束");
  18.  
  19.     }
  20.  
  21.     public static void main(String[] args) {
  22.         //两个线程访问一个对象的同步方法，对象为instance实例
  23.         Thread t1 = new Thread(instance);
  24.         Thread t2 = new Thread(instance);
  25.         t1.start();
  26.         t2.start();
  27.         while (t1.isAlive() || t2.isAlive()) {
  28.  
  29.         }
  30.         System.out.println("fininshed");
  31.     }
  32. }

运行结果：

  1. 对象锁的方法修饰符形式，我叫：Thread-0
  2. Thread-0 休眠3秒
  3. Thread-0运行结束
  4. 对象锁的方法修饰符形式，我叫：Thread-1
  5. Thread-1 休眠3秒
  6. Thread-1运行结束
  7. fininshed

解析：需要争抢同一把锁this，所以顺序执行。

2、两个线程访问的是两个对象的同步方法

代码：

  1. public class SynchronizedTwoThreadToTwoObject implements Runnable {
  2.     static SynchronizedTwoThreadToTwoObject instance1 = new SynchronizedTwoThreadToTwoObject();
  3.     static SynchronizedTwoThreadToTwoObject instance2 = new SynchronizedTwoThreadToTwoObject();
  4.  
  5.     @Override
  6.     public void run() {
  7.         // 当前对象作为锁
  8.         synchronized (this) {
  9.             System.out.println("我是对象锁的代码块形式，我叫" + Thread.currentThread().getName());
  10.             try {
  11.                 Thread.sleep(3000);
  12.             } catch (InterruptedException e) {
  13.                 e.printStackTrace();
  14.             }
  15.             System.out.println(Thread.currentThread().getName() + "运行结束");
  16.         }
  17.     }
  18.  
  19.     public static void main(String[] args) {
  20.         //两个线程访问的是两个对象的同步方法，两个对象一个为instance1,另一个为instance2
  21.         Thread t1 = new Thread(instance1);
  22.         Thread t2 = new Thread(instance2);
  23.         t1.start();
  24.         t2.start();
  25.         while (t1.isAlive() || t2.isAlive()) {
  26.  
  27.         }
  28.         System.out.println("fininshed");
  29.     }
  30. }

运行结果：

  1. 我是对象锁的代码块形式，我叫Thread-0
  2. 我是对象锁的代码块形式，我叫Thread-1
  3. Thread-1运行结束
  4. Thread-0运行结束
  5. fininshed

解析：并行处理，不受干扰，锁的实例不是同一个。

3、两个线程访问的是Synchronized的静态方法

代码：

  1. public class SynchronizedClassStatic implements Runnable {
  2.     static SynchronizedClassStatic instance1=new SynchronizedClassStatic();
  3.     static SynchronizedClassStatic instance2=new SynchronizedClassStatic();
  4.  
  5.     @Override
  6.     public void run() {
  7.         method();
  8.     }
  9.  
  10.     public static synchronized void method(){
  11.         System.out.println("我是类锁的一种形式，我叫"+Thread.currentThread().getName());
  12.         try {
  13.             Thread.sleep(3000);
  14.         } catch (InterruptedException e) {
  15.             e.printStackTrace();
  16.         }
  17.         System.out.println(Thread.currentThread().getName()+"线程结束");
  18.     }
  19.     
  20.     public static void main(String[] args){
  21.         //两个线程访问synchronized的静态方法
  22.         Thread t1=new Thread(instance1);
  23.         Thread t2=new Thread(instance2);
  24.         t1.start();
  25.         t2.start();
  26.         while (t1.isAlive()||t2.isAlive()){
  27.         }
  28.         System.out.println("fininshed");
  29.     }
  30. }

运行结果：

  1. 我是类锁的一种形式，我叫Thread-0
  2. Thread-0线程结束
  3. 我是类锁的一种形式，我叫Thread-1
  4. Thread-1线程结束
  5. fininshed

解析：对应的锁是同一把，一个一个的顺序执行。

4、同时访问同步方法与非同步方法

代码：

  1. public class SynchronizedYesOrNo implements Runnable {
  2.     static SynchronizedYesOrNo instance=new SynchronizedYesOrNo();
  3.     public static void main(String[] args) {
  4.         Thread th1=new Thread(instance);
  5.         Thread th2=new Thread(instance);
  6.         th1.start();
  7.         th2.start();
  8.         while(th1.isAlive()||th2.isAlive()){
  9.  
  10.         }
  11.         System.out.println("finished");
  12.     }
  13.  
  14.     @Override
  15.     public void run() {
  16.         if(Thread.currentThread().getName().equals("Thread-0")){
  17.             method1();
  18.         }else{
  19.             method2();
  20.         }
  21.     }
  22.  
  23.     public synchronized void method1(){
  24.         System.out.println("我是加了同步的方法"+Thread.currentThread().getName());
  25.         try {
  26.             Thread.sleep(3000);
  27.         } catch (InterruptedException e) {
  28.             // TODO Auto-generated catch block
  29.             e.printStackTrace();
  30.         }
  31.         System.out.println(Thread.currentThread().getName()+"结束");
  32.     }
  33.  
  34.     public synchronized static void method2(){
  35.         System.out.println("我是没加了同步的方法"+Thread.currentThread().getName());
  36.         try {
  37.             Thread.sleep(3000);
  38.         } catch (InterruptedException e) {
  39.             // TODO Auto-generated catch block
  40.             e.printStackTrace();
  41.         }
  42.         System.out.println(Thread.currentThread().getName()+"结束");
  43.  
  44.     }
  45. }

运行结果：

  1. 我是加了同步的方法Thread-0
  2. 我是没加了同步的方法Thread-1
  3. Thread-0结束
  4. Thread-1结束
  5. finished

解析：同步方法不会出现并发问题，非同步方法不会受到影响，出现并发问题。

5、访问同一个对象的不同的普通同步方法

代码：

  1. public class SynchronizedDifferentMethod implements Runnable {
  2.     static SynchronizedDifferentMethod instance=new SynchronizedDifferentMethod();
  3.  
  4.     @Override
  5.     public void run() {
  6.         if(Thread.currentThread().getName().equals("Thread-0")){
  7.             method1();
  8.         }else {
  9.             method2();
  10.         }
  11.     }
  12.  
  13.     public synchronized  void method1(){
  14.         System.out.println("我是加锁的方法"+Thread.currentThread().getName());
  15.         try {
  16.             Thread.sleep(3000);
  17.         } catch (InterruptedException e) {
  18.             e.printStackTrace();
  19.         }
  20.         System.out.println(Thread.currentThread().getName()+"线程执行结束");
  21.     }
  22.  
  23.     public synchronized void method2(){
  24.         System.out.println("我也是加锁的方法"+Thread.currentThread().getName()+"线程执行结束");
  25.         try {
  26.             Thread.sleep(3000);
  27.         } catch (InterruptedException e) {
  28.             e.printStackTrace();
  29.         }
  30.         System.out.println(Thread.currentThread().getName()+"线程执行结束");
  31.     }
  32.  
  33.     public static void main(String[] args) throws InterruptedException{
  34.         Thread t1=new Thread(instance);
  35.         Thread t2=new Thread(instance);
  36.         t1.start();
  37.         t2.start();
  38.         while (t1.isAlive()||t2.isAlive()){}
  39.         System.out.println("fininshed");
  40.     }
  41. }

运行结果：

  1. 我是加锁的方法Thread-0
  2. Thread-0线程执行结束
  3. 我也是加锁的方法Thread-1线程执行结束
  4. Thread-1线程执行结束
  5. fininshed

解析：拿到的是this锁，所以还是会受影响，串行执行。

6、同时访问静态synchronized和非静态synchronized

代码：

  1. public class SynchronizedStaticAndNormal implements Runnable {
  2.     static SynchronizedStaticAndNormal instance=new SynchronizedStaticAndNormal();
  3.  
  4.     @Override
  5.     public void run() {
  6.         if(Thread.currentThread().getName().equals("Thread-0")){
  7.             method1();
  8.         }else {
  9.             method2();
  10.         }
  11.  
  12.     }
  13.  
  14.     public synchronized static void method1(){
  15.         System.out.println("我是加锁的静态方法1 "+Thread.currentThread().getName());
  16.         try {
  17.             Thread.sleep(3000);
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  21.         System.out.println(Thread.currentThread().getName()+"线程执行结束");
  22.     }
  23.  
  24.     public synchronized void method2(){
  25.         System.out.println("我是加锁的非静态方法2 "+Thread.currentThread().getName());
  26.         try {
  27.             Thread.sleep(3000);
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         }
  31.         System.out.println(Thread.currentThread().getName()+"线程执行结束");
  32.     }
  33.  
  34.     public static void main(String[] args) throws InterruptedException{
  35.         Thread t1=new Thread(instance);
  36.         Thread t2=new Thread(instance);
  37.         t1.start();
  38.         t2.start();
  39.         while (t1.isAlive()||t2.isAlive()){}
  40.         System.out.println("fininshed");
  41.     }
  42. }

运行结果：

  1. 我是加锁的静态方法1 Thread-0
  2. 我是加锁的非静态方法2 Thread-1
  3. Thread-1线程执行结束
  4. Thread-0线程执行结束
  5. fininshed

解析：method1锁的是.class对象，method2锁的是this对象，锁不一样，没有冲突，并行执行。

7、方法抛异常后，会释放锁

代码：

  1. public class SynchronizedException implements Runnable {
  2.     static SynchronizedException instance = new SynchronizedException();
  3.  
  4.     @Override
  5.     public void run() {
  6.         if (Thread.currentThread().getName().equals("Thread-0")) {
  7.             method1();
  8.         } else {
  9.             method2();
  10.         }
  11.  
  12.     }
  13.  
  14.     public synchronized void method1() {
  15.         /*
  16.         // 抛出Exception
  17.         System.out.println("我是加锁的静态方法1" + Thread.currentThread().getName());
  18.         try {
  19.             Thread.sleep(3000);
  20.             //异常抛出后，JVM会自动帮你释放锁，不需要自己手动释放锁。
  21.             throw new Exception();
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         }
  27.         System.out.println(Thread.currentThread().getName() + "线程执行结束");
  28.         */
  29.  
  30.         // 抛出RuntimeException
  31.         System.out.println("我是加锁的静态方法1" + Thread.currentThread().getName());
  32.         try {
  33.             Thread.sleep(3000);
  34.         } catch (InterruptedException e) {
  35.             e.printStackTrace();
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.         }
  39.         //异常抛出后，JVM会自动帮你释放锁，不需要自己手动释放锁。
  40.         throw new RuntimeException();
  41.         // System.out.println(Thread.currentThread().getName() + "线程执行结束");
  42.     }
  43.  
  44.     public synchronized void method2() {
  45.         System.out.println("我也是加锁的非静态方法2" + Thread.currentThread().getName());
  46.         try {
  47.             Thread.sleep(3000);
  48.         } catch (InterruptedException e) {
  49.             e.printStackTrace();
  50.         }
  51.         System.out.println(Thread.currentThread().getName() + "线程执行结束");
  52.     }
  53.  
  54.     public static void main(String[] args) throws InterruptedException {
  55.         Thread t1 = new Thread(instance);
  56.         Thread t2 = new Thread(instance);
  57.         t1.start();
  58.         t2.start();
  59.         while (t1.isAlive() || t2.isAlive()) {
  60.         }
  61.         System.out.println("fininshed");
  62.     }
  63. }

运行结果：

  1. 我是加锁的静态方法1Thread-0
  2. Exception in thread "Thread-0" java.lang.RuntimeException
  3. 	at com.interview.javabasic.thread.a0914.SynchronizedException.method1(SynchronizedException.java:50)
  4. 	at com.interview.javabasic.thread.a0914.SynchronizedException.run(SynchronizedException.java:16)
  5. 	at java.lang.Thread.run(Thread.java:748)
  6. 我也是加锁的非静态方法2Thread-1
  7. Thread-1线程执行结束
  8. fininshed

解析：方法抛出异常后，会释放锁。

总结：

  1. 一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待（对应第1、5种情况）
  2. 每一个实例都对应有自己的一把锁，不同实例之间互不影响；例外：锁对象是 *.class 以及synchronized修饰的是static方法的时候，所有对象公用一把类锁（对应第2、3、4、6种情况）
  3. 无论方法正常执行完毕或者方法抛出异常，都会释放锁（对应第7种情况）。
  4. 目前进入被synchronized 的方法，在这方法里面调用没有synchronized修饰的方法。还是线程安全的吗？（不是线程安全的，出了synchronized，进入没有被synchronized修饰的方法，就可以同时被多个线程调用。）

参考文章：

不啰嗦，文章结束，期待三连！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/330269
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号