• 一文彻底理解synchronized（通俗易懂的synchronized）

    目录

    一、什么是synchronized

    二、synchronized的四种用法

    2.1、修饰一个代码块

    2.2、修饰一个方法

    2.3、修饰一个静态的方法

    2.4、修饰一个类

    三、使用案例分析

    3.1、修饰一个代码块

    3.2、修饰一个方法

    3.3、修饰一个静态的方法

    3.4、修饰一个类

    3.5 经典用法：

    总结

     

    一、什么是synchronized

    synchronized 是 Java 中的关键字，是一种同步锁。主要应用于多线程环境下保证线程的安全性。

    二、synchronized的四种用法

    2.1、修饰一个代码块

             被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象;

    2.2、修饰一个方法

            被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象;

            虽然可以使用 synchronized 来定义方法，但 synchronized 并不属于方法定义的一部分，因此，synchronized 关键字不能被继承。如果在父类中的某个方 法使用了 synchronized 关键字，而在子类中覆盖了这个方法，在子类中的这 个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上 synchronized 关键字才可以。当然，还可以在子类方法中调用父类中相应的方 法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此， 子类的方法也就相当于同步了。

    2.3、修饰一个静态的方法

    其作用的范围是整个静态方法，作用的对象是这个类的 所有对象;

    2.4、修饰一个类

    其作用的范围是synchronized后面括号括起来的部分，作用对象是这个类的所有对象。

    三、使用案例分析

    3.1、修饰一个代码块

    1) 一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。

    1. class SyncThread implements Runnable {
    2. 	   private static int count;
    3.  
    4. 	   public SyncThread() {
    5. 	      count = 0;
    6. 	   }
    7.  
    8. 	   public  void run() {
    9. 	      synchronized(this) {
    10. 	         for (int i = 0; i < 5; i++) {
    11. 	            try {
    12. 	               System.out.println(Thread.currentThread().getName() + ":" + (count++));
    13. 	               Thread.sleep(100);
    14. 	            } catch (InterruptedException e) {
    15. 	               e.printStackTrace();
    16. 	            }
    17. 	         }
    18. 	      }
    19. 	   }
    20.  
    21. 	   public int getCount() {
    22. 	      return count;
    23. 	   }
    24. }
    25.  
    26. public class SynchronizedDemo {
    27. 	public static void main(String args[]){
    28. //test01
    29. //		SyncThread s1 = new SyncThread();
    30. //		SyncThread s2 = new SyncThread();
    31. //		Thread t1 = new Thread(s1);
    32. //		Thread t2 = new Thread(s2);
    33. //test02		
    34. 		SyncThread s = new SyncThread();
    35. 		Thread t1 = new Thread(s);
    36. 		Thread t2 = new Thread(s);
    37. 		
    38. 		t1.start();
    39. 		t2.start();
    40. 	}
    41. }

    Test01

    test02

    从运行结果test02可以看出当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象

    为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联。

    2）当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。（作业：自行验证）

    3）指定要给某个对象加锁

    1. package CompleteFuture;
    2.  
    3.  
    4. /**
    5.  * 银行账户类
    6.  */
    7. class Account {
    8.     String name;
    9.     float amount;
    10.  
    11.     public Account(String name, float amount) {
    12.         this.name = name;
    13.         this.amount = amount;
    14.     }
    15.     //存钱
    16.     public  void deposit(float amt) {
    17.         amount += amt;
    18.         try {
    19.             Thread.sleep(100);
    20.         } catch (InterruptedException e) {
    21.             e.printStackTrace();
    22.         }
    23.     }
    24.     //取钱
    25.     public  void withdraw(float amt) {
    26.         amount -= amt;
    27.         try {
    28.             Thread.sleep(100);
    29.         } catch (InterruptedException e) {
    30.             e.printStackTrace();
    31.         }
    32.     }
    33.  
    34.     public float getBalance() {
    35.         return amount;
    36.     }
    37. }
    38.  
    39. /**
    40.  * 账户操作类
    41.  */
    42. class AccountOperator implements Runnable{
    43.     private Account account;
    44.     public AccountOperator(Account account) {
    45.         this.account = account;
    46.     }
    47.  
    48.     public void run() {
    49.         synchronized (account) {
    50.             account.deposit(500);
    51.             account.withdraw(500);
    52.             System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
    53.         }
    54.     }
    55. }
    56.  
    57.  
    58. public class SynchDemo2 {
    59.     //public static final Object signal = new Object(); // 线程间通信变量
    60.     //将account改为Demo00.signal也能实现线程同步
    61.     public static void main(String args[]){
    62.         Account account = new Account("zhang san", 10000.0f);
    63.         AccountOperator accountOperator = new AccountOperator(account);
    64.  
    65.         final int THREAD_NUM = 5;
    66.         Thread threads[] = new Thread[THREAD_NUM];
    67.         for (int i = 0; i < THREAD_NUM; i ++) {
    68.             threads[i] = new Thread(accountOperator, "Thread" + i);
    69.             threads[i].start();
    70.         }
    71.     }
    72. }

    在AccountOperator 类中的run方法里，我们用synchronized 给account对象加了锁。这时，当一个线程访问account对象时，其他试图访问account对象的线程将会阻塞，直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。 


    3.3 .1当有一个明确的对象作为锁时，就可以用类似下面这样的方式写程序。

    1. public void method3(SomeObject obj)
    2. {
    3.    //obj 锁定的对象
    4.    synchronized(obj)
    5.    {
    6.       // todo
    7.    }
    8. }

    3.3.2 当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁：

    1. class Test implements Runnable
    2. {
    3.    private byte[] lock = new byte[0];  // 特殊的instance变量
    4.    public void method()
    5.    {
    6.       synchronized(lock) {
    7.          // todo 同步代码块
    8.       }
    9.    }
    10.  
    11.    public void run() {
    12.  
    13.    }
    14. }

    3.2、修饰一个方法

    1. public void method()
    2. {
    3.    synchronized(this) {
    4.       // todo
    5.    }
    6. }

    在子类方法中加上synchronized关键字

    1. class Parent {
    2.    public synchronized void method() { }
    3. }
    4. class Child extends Parent {
    5.    public synchronized void method() { }
    6. }

    在子类方法中调用父类的同步方法

    1. class Parent {
    2.    public synchronized void method() {   }
    3. }
    4. class Child extends Parent {
    5.    public void method() { super.method();   }
    6. }
    1. 在定义接口方法时不能使用synchronized关键字。
    2. 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

    3.3、修饰一个静态的方法

    1. /**
    2.  * 同步线程
    3.  */
    4. class SyncThread implements Runnable {
    5.    private static int count;
    6.  
    7.    public SyncThread() {
    8.       count = 0;
    9.    }
    10.  
    11.    public synchronized static void method() {
    12.       for (int i = 0; i < 5; i ++) {
    13.          try {
    14.             System.out.println(Thread.currentThread().getName() + ":" + (count++));
    15.             Thread.sleep(100);
    16.          } catch (InterruptedException e) {
    17.             e.printStackTrace();
    18.          }
    19.       }
    20.    }
    21.  
    22.    public synchronized void run() {
    23.       method();
    24.    }
    25. }
    26.  
    27. public class Demo00{
    28. 	
    29. 	public static void main(String args[]){
    30. 		SyncThread syncThread1 = new SyncThread();
    31. 		SyncThread syncThread2 = new SyncThread();
    32. 		Thread t1 = new Thread(syncThread1, "SyncThread1");
    33. 		Thread t2 = new Thread(syncThread2, "SyncThread2");
    34. 		t1.start();
    35. 		t2.start();
    36. 	}
    37. }

    syncThread1和syncThread2是SyncThread的两个对象，但在t1和t2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。

    3.4、修饰一个类

    其作用的范围是synchronized后面括号括起来的部分，作用对象是这个类的所有对象。

    1. /**
    2.  * 同步线程
    3.  */
    4. class SyncThread implements Runnable {
    5.    private static int count;
    6.  
    7.    public SyncThread() {
    8.       count = 0;
    9.    }
    10.  
    11.    public static void method() {
    12.       synchronized(SyncThread.class) {
    13.          for (int i = 0; i < 5; i ++) {
    14.             try {
    15.                System.out.println(Thread.currentThread().getName() + ":" + (count++));
    16.                Thread.sleep(100);
    17.             } catch (InterruptedException e) {
    18.                e.printStackTrace();
    19.             }
    20.          }
    21.       }
    22.    }
    23.  
    24.    public synchronized void run() {
    25.       method();
    26.    }
    27. }

    3.5 经典用法：

    消费者与生产者

    1. package CompleteFuture;
    2.  
    3. import java.util.Random;
    4.  
    5. public class ProducerAndConsumer {
    6.     public static void main(String[] args) {
    7.  
    8.         //多线程如何编写
    9.         // 1、线程操作资源类
    10.         // 2、创建资源类 ，在资源类中创建属性和操作资源方法
    11.         Product product = new Product();
    12.         for (int i = 1; i < 10; i++) {
    13.             new Thread(new Runnable() {
    14.                 @Override
    15.                 public void run() {
    16.                     product.product();
    17.                 }
    18.             },"生产者: "+i).start();
    19.         }
    20.  
    21.         
    22.         for (int i = 1; i <10; i++) {
    23.             new Thread(new Runnable() {
    24.                 @Override
    25.                 public void run() {
    26.                     product.consume();
    27.                 }
    28.             },"消费者: "+i).start();
    29.         }
    30.     }
    31.     
    32. }
    33.  
    34. // 资源类
    35. class Product{
    36.  
    37.     private volatile int num = 0;
    38.     
    39.     public synchronized void  product(){
    40.  
    41.         // 1、馒头有的多我就可以不生产
    42.         while (num !=0){
    43.  
    44.             try {
    45.                 this.wait();
    46.             } catch (InterruptedException e) {
    47.                 e.printStackTrace();
    48.             }
    49.         }
    50.         // 一次生产五个
    51.         for (int i = 0; i <5 ; i++) {
    52.             ++num;
    53.         }
    54.         
    55.         // 产生了馒头通知消费者
    56.         this.notifyAll();
    57.         System.out.println(Thread.currentThread().getName()+"生产后剩余馒头："+num);
    58.  
    59.     }
    60.  
    61.  
    62.     public synchronized void  consume(){
    63.  
    64.         // 1、如果没有馒头我就等待，阻塞消费
    65.         while (num  == 0){
    66.  
    67.             try {
    68.                 this.wait();
    69.             } catch (InterruptedException e) {
    70.                 e.printStackTrace();
    71.             }
    72.         }
    73.         // 一次吃2个
    74.         for (int i = 0; i < 2; i++) {
    75.             if(num>0) {
    76.                 --num;
    77.             }
    78.         }
    79.  
    80.         // 模拟消耗馒头1s
    81.         try {
    82.             Thread.sleep(200);
    83.         } catch (InterruptedException e) {
    84.             e.printStackTrace();
    85.         }
    86.         this.notifyAll();
    87.         System.out.println(Thread.currentThread().getName()+"消费后剩余馒头："+num);
    88.     }
    89. }

    单例模式（双重检测）：


     

    总结

    A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。 
    B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。 
    C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。


    本文主要整理的是synchronized主要用法，但它实际的原理没有进行详细的拆解。且看下回剖析。

  • 相关阅读:
    Qt 项目实战 | 多界面文本编辑器
    笔者认为所谓的产业互联网，就是一个产业与互联网深度融合的过程
    AI大模型低成本快速定制法宝：RAG和向量数据库
    k8s部署
    socket进行服务器和客户端通信
    安卓玩机教程---全机型安卓4----安卓12 框架xp edx lsp安装方法
    寄存器、缓存、内存(虚拟、物理地址)、DDR、RAM的关系
    【Docker/K8S/Racher】Docker/K8S/Racher安装Redis-20220817
    并发中级(第一篇)
    理想之光不灭
  • 原文地址：https://blog.csdn.net/u010445301/article/details/133154016