Java:从单线程计数器到多线程数据同步synchronized和原子类Atomic

简介: Java:从单线程计数器到多线程数据同步synchronized和原子类Atomic

目录

使用单线程

使用多线程

使用多线程 + synchronized

使用多线程 + 原子类AtomicLong

使用单线程

单线程修改计数器的值,没有发生问题,每次运行结果都是10000,不过程序耗时较长


package com.example;


/**

* 计数器

*/

class Counter {

   private static long count;


   public static long getCount() {

       return count;

   }


   public static void incrementCount() {

       count++;

   }

}



public class Demo {

   public static void main(String[] args) throws InterruptedException {

       long count = Counter.getCount();

       System.out.println(count);

       // 0


       for (int i = 0; i < 10000; i++) {

           try {

               Thread.sleep(1);

           } catch (InterruptedException e) {

               e.printStackTrace();

           }

           Counter.incrementCount();

       }

     

       count = Counter.getCount();

       System.out.println(count);

       // 10000

   }

}



使用多线程

单线程修改计数器的值,运行速度提高了,不过运行结果每次都不一致,而且结果不是10000


package com.example;


import java.util.ArrayList;

import java.util.List;


/**

* 计数器

*/

class Counter {

   private static long count;


   public static long getCount() {

       return count;

   }


   public static void incrementCount() {

       count++;

   }

}



public class Demo {

   public static void main(String[] args) throws InterruptedException {

       long count = Counter.getCount();

       System.out.println(count);

       // 0


       List<Thread> list = new ArrayList<>();


       // 启动10000个线程同时访问计数器

       for (int i = 0; i < 10000; i++) {

           Thread thread = new Thread(new Runnable() {

               @Override

               public void run() {

                   try {

                       Thread.sleep(1);

                   } catch (InterruptedException e) {

                       e.printStackTrace();

                   }

                   Counter.incrementCount();

               }

           });

           list.add(thread);

       }


       for (Thread thread : list) {

           thread.start();

       }


       for (Thread thread : list) {

           thread.join();

       }


       count = Counter.getCount();

       System.out.println(count);

   }


执行结果


第一次:9910

第二次:9912

第三次:9910


使用多线程 + synchronized

多线程加锁后,最后结果都是10000


package com.example;


import java.util.ArrayList;

import java.util.List;


/**

* 计数器

*/

class Counter {

   private static long count;


   public static long getCount() {

       return count;

   }


   public static synchronized void incrementCount() {

       count++;

   }

}



public class Demo {

   public static void main(String[] args) throws InterruptedException {

       long count = Counter.getCount();

       System.out.println(count);

       // 0


       List<Thread> list = new ArrayList<>();


       // 启动10000个线程同时访问计数器

       for (int i = 0; i < 10000; i++) {

           Thread thread = new Thread(new Runnable() {

               @Override

               public void run() {

                   try {

                       Thread.sleep(1);

                   } catch (InterruptedException e) {

                       e.printStackTrace();

                   }

                   Counter.incrementCount();

               }

           });

           list.add(thread);

       }


       for (Thread thread : list) {

           thread.start();

       }


       for (Thread thread : list) {

           thread.join();

       }


       count = Counter.getCount();

       System.out.println(count);

   }

}


执行结果


第一次:10000

第二次:10000

第三次:10000


使用多线程 + 原子类AtomicLong

多线程中使用原子类AtomicLong实现计数器,最后结果都是10000


原理是CAS(Compare and Set):


先比较原始值和预期值,如果相等,则修改为新值;

不相等则修改失败

伪代码如下


bool compareAndSet(oldValue, expectValue, updateValue){

   if(oldValue == expectValue){

       oldValue = updateValue

       // update success

   } else{

       // update fail

   }

}


package com.example;


import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.atomic.AtomicLong;


/**

* 计数器

*/

class Counter {

   private static AtomicLong count = new AtomicLong(0);


   public static long getCount() {

       return count.get();

   }


   public static void incrementCount() {

       count.incrementAndGet();

   }

}



public class Demo {

   public static void main(String[] args) throws InterruptedException {

       long count = Counter.getCount();

       System.out.println(count);

       // 0


       List<Thread> list = new ArrayList<>();


       // 启动10000个线程同时访问计数器

       for (int i = 0; i < 10000; i++) {

           Thread thread = new Thread(new Runnable() {

               @Override

               public void run() {

                   try {

                       Thread.sleep(1);

                   } catch (InterruptedException e) {

                       e.printStackTrace();

                   }

                   Counter.incrementCount();

               }

           });

           list.add(thread);

       }


       for (Thread thread : list) {

           thread.start();

       }


       for (Thread thread : list) {

           thread.join();

       }


       count = Counter.getCount();

       System.out.println(count);

   }

}


执行结果


第一次:10000

第二次:10000

第三次:10000

————————————————

版权声明:本文为CSDN博主「彭世瑜」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。

原文链接:https://blog.csdn.net/mouday/article/details/130923836

相关文章
|
人工智能 安全 Java
Java并发包下Atomic相关类的使用
本文介绍了 `java.util.concurrent.atomic` 包下的各类原子类及其使用场景,包括基本类型原子类(如 `AtomicInteger`、`AtomicLong`)、数组类型原子类(如 `AtomicIntegerArray`)、引用类型原子类(如 `AtomicReference`)、对象属性修改原子类(如 `AtomicIntegerFieldUpdater`)以及原子操作增强类(如 `LongAdder` 和 `LongAccumulator`)。同时,详细对比了不同原子类在高并发场景下的性能表现,展示了 `LongAdder` 的高效性。
360 31
|
存储 缓存 人工智能
【原理】【Java并发】【synchronized】适合中学者体质的synchronized原理
本文深入解析了Java中`synchronized`关键字的底层原理,从代码块与方法修饰的区别到锁升级机制,内容详尽。通过`monitorenter`和`monitorexit`指令,阐述了`synchronized`实现原子性、有序性和可见性的原理。同时,详细分析了锁升级流程:无锁 → 偏向锁 → 轻量级锁 → 重量级锁,结合对象头`MarkWord`的变化,揭示JVM优化锁性能的策略。此外,还探讨了Monitor的内部结构及线程竞争锁的过程,并介绍了锁消除与锁粗化等优化手段。最后,结合实际案例,帮助读者全面理解`synchronized`在并发编程中的作用与细节。
1234 8
【原理】【Java并发】【synchronized】适合中学者体质的synchronized原理
|
缓存 安全 Java
【Java并发】【synchronized】适合初学者体质入门的synchronized
欢迎来到我的Java线程同步入门指南!我不是外包员工,梦想是写高端CRUD。2025年我正在沉淀中,博客更新速度加快,欢迎点赞、收藏、关注。 本文介绍Java中的`synchronized`关键字,适合初学者。`synchronized`用于确保多个线程访问共享资源时不会发生冲突,避免竞态条件、保证内存可见性、防止原子性破坏及协调多线程有序访问。
525 8
【Java并发】【synchronized】适合初学者体质入门的synchronized
|
安全 算法 Java
Java 中 synchronized 与 AtomicInteger 的区别
在Java多线程编程中,`synchronized`和`AtomicInteger`均用于实现线程安全,但原理与适用场景不同。`synchronized`是基于对象锁的同步机制,适用于复杂逻辑和多变量同步,如银行转账;而`AtomicInteger`采用CAS算法,适合单一变量的原子操作,例如计数器更新。二者各有优劣,应根据具体需求选择使用。
450 0
|
安全 Java 程序员
【高薪程序员必看】万字长文拆解Java并发编程!(6-2):从CAS无锁机制到Atomic原子类实战指南
🌟 ​🌟今天给大家带来的是 ​💻⚡在这篇文章中,我们将一起探索:🔹 ​的底层原理,它是如何通过 ​实现无锁并发的?🔹 ​的终极对决,为什么高并发场景下CAS性能更优?🔹 ​的陷阱与解决方案——和实战演示!🔹 ​​(LongAdder等)的使用场景与性能对比🔹 危险的 ​黑魔法:为什么阿里禁止使用却又是并发库的基石?无论你是:✅ ​​(BATJ高频考点)✅ ​​(如何设计百万级计数器)✅ ​​(从Java代码到CPU指令的全链路分析)这篇文章都会让你收获满满!✨。
275 0
|
安全 Java 程序员
【高薪程序员必看】万字长文拆解Java并发编程!(6-1):从CAS无锁机制到Atomic原子类实战指南
🌟 ​🌟今天给大家带来的是 ​💻⚡在这篇文章中,我们将一起探索:🔹 ​的底层原理,它是如何通过 ​实现无锁并发的?🔹 ​的终极对决,为什么高并发场景下CAS性能更优?🔹 ​的陷阱与解决方案——和实战演示!🔹 ​​(LongAdder等)的使用场景与性能对比🔹 危险的 ​黑魔法:为什么阿里禁止使用却又是并发库的基石?无论你是:✅ ​​(BATJ高频考点)✅ ​​(如何设计百万级计数器)✅ ​​(从Java代码到CPU指令的全链路分析)这篇文章都会让你收获满满!✨。
327 0
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
486 7
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式:助您写出线程安全的代码
`synchronized` 是 Java 中的关键字,用于实现线程同步,确保多个线程互斥访问共享资源。它通过内置的监视器锁机制,防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块,分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器,JDK 1.6 后引入了偏向锁、轻量级锁等优化措施,提高了性能。
1047 3
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
289 4
|
算法 Java 程序员
Java中的Synchronized,你了解多少?
Java中的Synchronized,你了解多少?
331 4

热门文章

最新文章