• 多线程（二）多线程的锁机制（java）

    目录

     一、前言：

    二、 synchronized（对类、方法、代码块加锁-非公平锁）

          2.1 概念 

          2.2 用法

               2.2.1  对方法中的代码块进行加对象锁（对象锁）

               2.2.2  对普通方法进行加锁（对象锁）

               2.2.3  对静态方法加锁（类锁）

     ​编辑

    三、 volatile （声明对多线程都可见的资源信息）

          3.1 概念

          3.2 用法

                 3.2.1  可见性（一个线程修改，一个线程观察）

          3.2.2   有序性（经典的单例设计模式的例子）

    四、ReentrantLock（实现lock接口的AQS锁）

          4.1 概念

          4.2 用法

                    4.2.1 使用ReentrantLock进行加解锁

                    4.2.2 公平锁示范（按照顺序获取到锁）

                    4.2.3 非公平锁示范 （随机获取到锁）

     

    五、CAS （compare and swap  比较交换）

            5.1 cas概念

            5.2 synchronized与CAS进行比较

     一、前言：

            对于上文中，我们知道了什么是线程和进程，同时也知道了对于多线程进行同一个资源（变量）操作的时候，会产生线程安全的问题，那么为了这个问题，我们最合理的方式一般有两种：

          其一：对该资源进行控制，同一时刻只允许单个线程对此资源进行操作 ;

          其二：将该资源分割成若干等分并分配给单个线程，作为私有资源进行处理。

    往往第二种方式瞬息万变的外在环境下不太好进行分割控制，故一般我们采用第一种方式；第一种方式的落地方案就是多线程的锁机制。

    二、 synchronized（对类、方法、代码块加锁-非公平锁）

          2.1 概念 

             synchronized是java关键字，主要作用是对以一个类或其对象作为标识，对某段代码块进行锁定，只有获取该标识的线程才能执行synchronized标识作用域（代码块或方法）的代码。当代码块中的代码发生异常时，synchronized会自动释放锁。

            一般的如果是直接将synchronized关键字用在了普通方法上，那么默认是加了一个对象锁，如果是放在了静态方法上面，那么就是使用了类锁。对于代码块，形如 xxxx.class的代码块则相当于加上了类锁，如果是使用某个实例对象，这是对这个对象加锁。对于加了锁的执行都需要获取锁之后才能进行，如果中间发生了任何异常，synchronized会自动释放锁资源。

                特别注意： synchronized锁对象不要用String、Integer等包装类型的对象。（1. 当其值发生变化的时候，其对象也发生了改变，容易被忽略。2. 例如String lockKey =  123+12等进行凭借的时候，会发生意想不到的情况。）

          2.2 用法

               2.2.1  对方法中的代码块进行加对象锁（对象锁）

    示例：

    1.     public static void main(String[] args) {
    2.         Object o = new Object();
    3.  
    4.         new Thread(new Runnable() {
    5.             @Override
    6.             public void run() {
    7.                 synchronized (o) {
    8.                     System.out.println("I get the lock and please all thread waiting 60s");
    9.                     TimeUtils.sleep(1000);
    10.                     System.out.println("waiting end!");
    11.                 }
    12.             }
    13.         }).start();
    14.  
    15.         // 防止下面代码在run方法之前执行，休息0.1秒
    16.         TimeUtils.sleep(100);
    17.  
    18.         synchronized (o) {
    19.             System.out.println("I get the lock");
    20.         }
    21.     }

     

    结果：

     

               2.2.2  对普通方法进行加锁（对象锁）

    示例：

    1. public class T_Synchronized {
    2.  
    3.  
    4.     public static void main(String[] args) {
    5.         T_Synchronized t = new T_Synchronized();
    6.  
    7.         new Thread(new Runnable() {
    8.             @Override
    9.             public void run() {
    10.                 t.print("我是新建的线程");
    11.             }
    12.         }).start();
    13.  
    14.         // 保证run方法先运行
    15.         TimeUtils.sleep(100);
    16.  
    17.         t.print("我是主函数里面的线程");
    18.     }
    19.  
    20.  
    21.     public synchronized void print(String words) {
    22.         System.out.println("thread:" + Thread.currentThread().getName() + ",print[" + words + "]");
    23.         TimeUtils.sleep(2000);
    24.         System.out.println("thread:" + Thread.currentThread().getName() + " print end");
    25.     }
    26.  
    27.  
    28. }

    结果：

               2.2.3  对静态方法加锁（类锁）

    示例：

     

    1. public class T03_Synchronized {
    2.  
    3.     public synchronized static void print() {
    4.         System.out.println("T03_Synchronized created " + TimeUtils.currentTime());
    5.     }
    6.  
    7.  
    8.     public static void main(String[] args) {
    9.         new Thread(new Runnable() {
    10.             @Override
    11.             public void run() {
    12.                 synchronized (T03_Synchronized.class) {
    13.                     TimeUtils.sleep(1000);
    14.                     System.out.println("sleep end");
    15.                 }
    16.             }
    17.         }).start();
    18.  
    19.         TimeUtils.sleep(100);
    20.  
    21.         T03_Synchronized.print();
    22.     }
    23. }

    结果：

    Java锁机制详解.pdf
    pdf 0星 超过10%的资源 208KB
    下载

     

    三、 volatile （声明对多线程都可见的资源信息）

          3.1 概念

            volatile也是java中的一个较为常见的关键字，主要用于修饰java中的变量，使得这个变量具有在各个线程中的可见性。其主要作用有：

            1. 可见性，当被volatile修饰的变量在发生修改时，使用其变量的线程回去主内存更新该值数据，以保证其修改后的数据被各个线程可见。（可见但并不保证其原子性）

            2. 有序性，当变量volatile被修饰后，不会被指令重排序掉。

          3.2 用法

                 3.2.1  可见性（一个线程修改，一个线程观察）

                        示例：

    1. public class T01_volatile {
    2.  
    3.     public volatile static Integer num = 0;
    4.  
    5.     public static void main(String[] args) {
    6.  
    7.         // 写线程
    8.         new Thread(new Runnable() {
    9.             @Override
    10.             public void run() {
    11.                 while (num < 5) {
    12.                     TimeUtils.sleep(1000);
    13.                     num++;
    14.                     System.out.println(Thread.currentThread().getName() + "--> num has add and now is " + num);
    15.                 }
    16.             }
    17.         }).start();
    18.  
    19.         TimeUtils.sleep(500);
    20.  
    21.  
    22.         // 读线程
    23.         new Thread(new Runnable() {
    24.             @Override
    25.             public void run() {
    26.                 while (num < 5) {
    27.                     TimeUtils.sleep(1000);
    28.                     System.out.println(Thread.currentThread().getName() + "--> I read num is " + num);
    29.                 }
    30.             }
    31.         }).start();
    32.  
    33.  
    34.     }
    35.  
    36. }

    结果：

          3.2.2   有序性（经典的单例设计模式的例子）

                示例：

    1. public class T02_volatile {
    2.  
    3.  
    4.     private static volatile T02_volatile instance;
    5.  
    6.  
    7.     private T02_volatile() {
    8.     }
    9.  
    10.     public T02_volatile getInstance() {
    11.  
    12.         if (instance == null) {
    13.             synchronized (this) {
    14.                 if (instance == null) {
    15.                     instance = new T02_volatile();
    16.                 }
    17.             }
    18.         }
    19.  
    20.         return instance;
    21.         
    22.     }
    23.  
    24. }

    四、ReentrantLock（实现lock接口的AQS锁）

          4.1 概念

                    ReentrantLock是是实现了lock接口的AQS（AbstractQueuedSynchronizer）锁，其和synchronized区别主要有：1. 使用lock和unlock方法进行加锁和解锁过程。2. 当发生异常时，synchronized会主动进行释放过程，但是ReentrantLock这需要使用try{}cathe进行异常捕捉和进行释放。3. 其二都是可重入的锁。4. synchronized是非公平锁，但是ReentrantLock是公平锁。

          4.2 用法

                    4.2.1 使用ReentrantLock进行加解锁

    1. public class T_ReentrantLock {
    2.  
    3.  
    4.     public static void main(String[] args) {
    5.         Lock lock = new ReentrantLock();
    6.  
    7.         lock.lock();
    8.  
    9.         try {
    10.  
    11.         } catch (Exception e) {
    12.  
    13.         } finally {
    14.             lock.unlock();
    15.         }
    16.  
    17.  
    18.     }
    19.  
    20.  
    21. }

                    4.2.2 公平锁示范（按照顺序获取到锁）

    1. public class T01_ReentrantLock {
    2.  
    3.  
    4.     public static void main(String[] args) {
    5.  
    6.         // 创建一个公平锁的对象
    7.         Test test = new Test(true);
    8.  
    9.         for (int i = 0; i < 5; i++) {
    10.             new Thread(new Runnable() {
    11.                 @Override
    12.                 public void run() {
    13.                     test.print();
    14.                 }
    15.             }).start();
    16.         }
    17.  
    18.     }
    19.  
    20.  
    21.     public static class Test {
    22.  
    23.         private ReentrantLock lock;
    24.  
    25.         public Test() {
    26.             // 创建非公平的ReentrantLock锁
    27.             this.lock = new ReentrantLock(true);
    28.         }
    29.  
    30.         public Test(boolean fair) {
    31.             this.lock = new ReentrantLock(fair);
    32.         }
    33.  
    34.         public void print() {
    35.             lock.lock();
    36.  
    37.             try {
    38.                 System.out.println(Thread.currentThread().getName() + "获取到锁");
    39.                 TimeUtils.sleep(1000);
    40.             } catch (Exception e) {
    41.  
    42.             } finally {
    43.                 System.out.println(Thread.currentThread().getName() + "释放锁");
    44.                 lock.unlock();
    45.             }
    46.         }
    47.  
    48.  
    49.     }
    50.  
    51.  
    52. }

    运行结果：

                    4.2.3 非公平锁示范 （随机获取到锁）

    Java多线程之显示锁和内置锁总结详解
    pdf 0星 超过10%的资源 83KB
    下载

    主要是在4.2.2的基础上，将 Test test = new Test(true); 改成  Test test = new Test(false);

            

    1. public class T01_ReentrantLock {
    2.  
    3.  
    4.     public static void main(String[] args) {
    5.  
    6.         Test test = new Test(false);
    7.         for (int i = 0; i < 5; i++) {
    8.             new Thread(new Runnable() {
    9.                 @Override
    10.                 public void run() {
    11.                     test.print();
    12.                 }
    13.             }).start();
    14.         }
    15.  
    16.     }
    17.  
    18.  
    19.     public static class Test {
    20.  
    21.         private ReentrantLock lock;
    22.  
    23.         public Test() {
    24.             // 创建非公平的ReentrantLock锁
    25.             this.lock = new ReentrantLock(true);
    26.         }
    27.  
    28.         public Test(boolean fair) {
    29.             this.lock = new ReentrantLock(fair);
    30.         }
    31.  
    32.         public void print() {
    33.             lock.lock();
    34.  
    35.             try {
    36.                 System.out.println(Thread.currentThread().getName() + "获取到锁");
    37.                 TimeUtils.sleep(1000);
    38.             } catch (Exception e) {
    39.  
    40.             } finally {
    41.                 System.out.println(Thread.currentThread().getName() + "释放锁");
    42.                 lock.unlock();
    43.             }
    44.         }
    45.  
    46.  
    47.     }
    48.  
    49.  
    50. }

    结果：

     

     

                    

    五、CAS （compare and swap  比较交换）

            5.1 cas概念

                    cas：从字面意思是先比较再进行值的交换；也就是说比如某个变量x，我们需要将其从值A变成B时，首先我们先知道这个要变的变量x，并且知道其当前的值是x=A，下一步进行值变换的时候要比较一下，在我在准备和正在变换的过程中这个变量x的值还是不是A，如果是这进行变换，不是则失败，这就是cas的概念和核心原理。

                    ABA问题：  当进行cas的时候会发现一个事情，就是当我们需要将A转换成B时，可能这个值已经从A转换成C再转换成了A，那么此时再进行变更的时候发现其状态已经发生了改变，那么这个问题如何解决了？很简答，加个版本号，那么比较不仅仅只是值比较了，还有其版本比较，每个将此资源修改之后都将更新其版本号，便可以杜绝此类问题 。

            5.2 synchronized与CAS进行比较

             我们可以进行以下比较，将数字从0加到一百万，来比较 synchronized、AutomaticInteger、LongAdder的运行效率，可以得出一些结果：

            synchronized：所有线程都会被这个锁住，获取到锁的更新后被不公平的分配给其他线程进行增加，速度较慢。

            AutomaticInteger：基于CAS的自旋锁，没有加锁和解锁的过程，拼手速了，速度较快。

            LongAdder：分段CAS锁，这个会将这个按照策略分配不同的粒度，分段计算后进行相加，对于数量比较大的数据速度应该是这三者最快的。

            示例和结果如下：

    1. public class T01_Cas {
    2.  
    3.     // sync 锁，线程都要阻塞
    4.     static long count1 = 0L;
    5.  
    6.     //CAS操作，无锁原子操作，效率更高
    7.     static AtomicLong count2 = new AtomicLong(0L);
    8.  
    9.     // 分段锁（锁内CAS操作）--将所有的线程分成几个等分，然后将几个线程的数据统一再加起来
    10.     static LongAdder count3 = new LongAdder();
    11.  
    12.     public static void main(String[] args) {
    13.         T01_Cas t01 = new T01_Cas();
    14.  
    15.         t01.syncCount();
    16.  
    17.         t01.AtomicCount();
    18.  
    19.         t01.LongAdderCount();
    20.     }
    21.  
    22.     public void syncCount() {
    23.  
    24.         final Object o = new Object();
    25.         List threads = new ArrayList<>(10);
    26.  
    27.         Long start = System.currentTimeMillis();
    28.  
    29.         for (int i = 0; i < 10; i++) {
    30.             threads.add(new Thread(new Runnable() {
    31.                 @Override
    32.                 public void run() {
    33.  
    34.                     for (int i = 0; i < 100000; i++) {
    35.                         synchronized (o) {
    36.                             count1++;
    37.                         }
    38.                     }
    39.  
    40.                 }
    41.             }));
    42.         }
    43.  
    44.         for (Thread t : threads) t.start();
    45.         for (Thread t : threads) {
    46.             try {
    47.                 t.join();
    48.             } catch (InterruptedException e) {
    49.                 e.printStackTrace();
    50.             }
    51.         }
    52.  
    53.         System.out.println("sync 执行结果是：" + count1 + ",执行时间为：" + (System.currentTimeMillis() - start) + "ms");
    54.  
    55.     }
    56.  
    57.     public void AtomicCount() {
    58.  
    59.         final Object o = new Object();
    60.         List threads = new ArrayList<>(10);
    61.  
    62.         Long start = System.currentTimeMillis();
    63.  
    64.         for (int i = 0; i < 10; i++) {
    65.             threads.add(new Thread(new Runnable() {
    66.                 @Override
    67.                 public void run() {
    68.  
    69.                     for (int i = 0; i < 100000; i++) {
    70.                         count2.incrementAndGet();
    71.                     }
    72.  
    73.                 }
    74.             }));
    75.         }
    76.  
    77.         for (Thread t : threads) t.start();
    78.         for (Thread t : threads) {
    79.             try {
    80.                 t.join();
    81.             } catch (InterruptedException e) {
    82.                 e.printStackTrace();
    83.             }
    84.         }
    85.  
    86.         System.out.println("AtomicLong 执行结果是：" + count2 + ",执行时间为：" + (System.currentTimeMillis() - start) + "ms");
    87.  
    88.     }
    89.  
    90.     public void LongAdderCount() {
    91.  
    92.         final Object o = new Object();
    93.         List threads = new ArrayList<>(10);
    94.  
    95.         Long start = System.currentTimeMillis();
    96.  
    97.         for (int i = 0; i < 10; i++) {
    98.             threads.add(new Thread(new Runnable() {
    99.                 @Override
    100.                 public void run() {
    101.  
    102.                     for (int i = 0; i < 100000; i++) {
    103.                         count3.increment();
    104.                     }
    105.  
    106.                 }
    107.             }));
    108.         }
    109.  
    110.         for (Thread t : threads) t.start();
    111.         for (Thread t : threads) {
    112.             try {
    113.                 t.join();
    114.             } catch (InterruptedException e) {
    115.                 e.printStackTrace();
    116.             }
    117.         }
    118.  
    119.         System.out.println("LongAdder 执行结果是：" + count1 + ",执行时间为：" + (System.currentTimeMillis() - start) + "ms");
    120.  
    121.     }
    122. }

            结果：

     

    上一章：多线程（一）线程与进程

  • 相关阅读:
    C++ 空类中有哪些成员函数
    在3分钟内使用AI-Chat生成精美PPT（附AI工具）
    VUE学习：vue简介、vue指令
    Java读取单个大文件的json数据避免内存溢出
    zookeeper、Dubbo
    嵌入式开发--CubeMX使用入门教程
    qt实现了音乐播放器2.0版本
    华为推出HarmonyOS 3.0，更智能、更安全，首批更新你的机型吗？
    独一无二的设计模式——单例模式（Java实现）
    【Linux】chown命令使用
  • 原文地址：https://blog.csdn.net/weixin_44929998/article/details/126065210