Synchronized、Lock和Atomic性能测试

最新推荐文章于 2021-08-19 13:23:01 发布
最新推荐文章于 2021-08-19 13:23:01 发布
阅读量248 收藏
点赞数 1
分类专栏： java实战 文章标签： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/freerme/article/details/103883655
版权

Synchronized、Lock和Atomic性能测试

模拟8线程，其中4线程写操作，4线程读操作，分别测试无任何同步机制下(线程不安全)、Synchronized、Lock和Atomic原子类的循环N次计算的性能

package concurrency;

import java.util.Random;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


// 普通方法/Synchronized内置锁/Lock显示锁/Atomic操作的性能对比 单位(纳秒)
abstract class Accumulator {
    public static long cycles = 50000l;
    private static final int N = 4;
    public static ExecutorService exec = Executors.newFixedThreadPool(N * 2);
    private static CyclicBarrier barrier =
            new CyclicBarrier(N*2 + 1);
    protected volatile int index = 0;
    protected volatile long value = 0;
    protected long duration = 0;
    protected String id = "error";
    protected final static int SIZE = 100000;
    protected static int[] preLoaded = new int[SIZE];

    static  {
        Random rand = new Random(47);
        for (int i = 0; i < SIZE; i++) {
            preLoaded[i] = rand.nextInt();
        }

    }

    public abstract void accumulate();
    public abstract long read();
    private class Modifier implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < cycles; i++) {
                accumulate();
            }
            try {
                barrier.await();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    private class Reader implements Runnable {
        private volatile long value;

        @Override
        public void run() {
            for (int i = 0; i < cycles; i++) {
                value = read();
            }
            try {
                barrier.await();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    public void timedTest() {
        long start = System.nanoTime();
        for (int i = 0; i < N; i++) {
            exec.execute(new Modifier());
            exec.execute(new Reader());
        }
        try {
            barrier.await();  // 保障当前cycles测试完毕，才会进入下一个新cycles测试
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        duration = System.nanoTime() - start;
        System.out.print(String.format("%-13s: %13d\n", id, duration));
    }
    public static void report(Accumulator acc1, Accumulator acc2) {
        System.out.print(String.format("%-22s: %.2f\n", acc1.id + "/" + acc2.id,
                (double) acc1.duration / (double) acc2.duration));
    }
}

class BaseLine extends Accumulator {
    { id = "BaseLine"; }
    public void accumulate() {
        int ind = index++;
        if (ind >= SIZE) {
            index = 0;
            value += preLoaded[0];
        } else {
            value += preLoaded[ind];

        }
    }

    public long read() { return value; }
}


class SynchronizedTest extends Accumulator {
    { id = "Synchronized"; }
    public synchronized void accumulate() {
        value += preLoaded[index++];
        if (index >= SIZE) index = 0;
    }

    public synchronized long read() { return value; }
}

class LockTest extends Accumulator {
    { id = "Lock"; }
    private Lock lock = new ReentrantLock();
    @Override
    public void accumulate() {
        lock.lock();
        try {
            value += preLoaded[index++];
            if (index >= SIZE) index = 0;
        } finally {
            lock.unlock();
        }
    }
    public long read() {
        lock.lock();
        try {
            return value;
        } finally {
            lock.unlock();
        }
    }
}

class AtomicTest extends Accumulator {
    { id = "Atomic"; }
    private AtomicInteger index = new AtomicInteger(0);
    private AtomicLong value = new AtomicLong(0);
    public void accumulate() {
        int i = index.getAndIncrement();
        if (i >= SIZE) {
            index.set(0);
            value.getAndAdd(0);
        } else {
            value.getAndAdd(preLoaded[i]);
        }

    }

    public long read() {
        return value.get();
    }
}
public class SynchronizationComarisons {
    static BaseLine baseLine = new BaseLine();
    static SynchronizedTest synch = new SynchronizedTest();
    static LockTest lock = new LockTest();
    static AtomicTest atomic = new AtomicTest();
    static void test() {
        System.out.println("==================================");
        System.out.print(String.format("%-12s : %13d\n", "Cycles", Accumulator.cycles));
        baseLine.timedTest();
        synch.timedTest();
        lock.timedTest();
        atomic.timedTest();
        Accumulator.report(synch, baseLine);
        Accumulator.report(lock, baseLine);
        Accumulator.report(atomic, baseLine);
        Accumulator.report(synch, lock);
        Accumulator.report(synch, atomic);
        Accumulator.report(lock, atomic);
    }

    public static void main(String[] args) {
        int iterations = 5;
        System.out.println("Warmup");
        baseLine.timedTest();
        for (int i = 0; i < iterations; i++) {
            test();
            Accumulator.cycles *= 2;
        }
        Accumulator.exec.shutdownNow();
    }
}
/*output
Warmup
BaseLine     :      13460648
==================================
Cycles       :         50000
BaseLine     :      10290073
Synchronized :      37646432
Lock         :      26474879
Atomic       :      18850147
Synchronized/BaseLine : 3.66
Lock/BaseLine         : 2.57
Atomic/BaseLine       : 1.83
Synchronized/Lock     : 1.42
Synchronized/Atomic   : 2.00
Lock/Atomic           : 1.40
==================================
Cycles       :        100000
BaseLine     :      21884237
Synchronized :     114442272
Lock         :      44680671
Atomic       :      13101746
Synchronized/BaseLine : 5.23
Lock/BaseLine         : 2.04
Atomic/BaseLine       : 0.60
Synchronized/Lock     : 2.56
Synchronized/Atomic   : 8.73
Lock/Atomic           : 3.41
==================================
Cycles       :        200000
BaseLine     :      42549456
Synchronized :     232285601
Lock         :      88711627
Atomic       :      24815086
Synchronized/BaseLine : 5.46
Lock/BaseLine         : 2.08
Atomic/BaseLine       : 0.58
Synchronized/Lock     : 2.62
Synchronized/Atomic   : 9.36
Lock/Atomic           : 3.57
==================================
Cycles       :        400000
BaseLine     :      84727978
Synchronized :     477743405
Lock         :     170432430
Atomic       :      54460812
Synchronized/BaseLine : 5.64
Lock/BaseLine         : 2.01
Atomic/BaseLine       : 0.64
Synchronized/Lock     : 2.80
Synchronized/Atomic   : 8.77
Lock/Atomic           : 3.13
==================================
Cycles       :        800000
BaseLine     :     166554952
Synchronized :     916578204
Lock         :     355592796
Atomic       :     113692781
Synchronized/BaseLine : 5.50
Lock/BaseLine         : 2.13
Atomic/BaseLine       : 0.68
Synchronized/Lock     : 2.58
Synchronized/Atomic   : 8.06
Lock/Atomic           : 3.13
* */

随着循环次数cycles成倍增大，Synchronized的性能明显变差，Atomic和Lock的性能始终处于稳定状态，从结果看Atomic类性能更高，但Atomic类只有在非常简单的情况下才有用，这些情况通常包括你只有一个要被修改的Atomic对象，并且这个对象独立于其他所有的对象。更安全正确的做法是：以更加传统的方式入手，只有在性能方面的需求能够明确指示时，才替换为Atomic。



、﹗∕
— 〇 -
╱︱ ヽ
♥ 但行好事、莫问前程！
☀>.freerme、我是lilee[https://blog.csdn.net/freerme]
_________________ *_*______
♥
♥ ♥
♥
____ ____ ____
我是lilee
关注
专栏目录
Synchronized 、Atomic 对比 -- JAVA 进阶
qishun2xiao的博客
10-01 1553
在学习CAS无锁时候，总是难免拿来与Synchronized进行比较。 首先先来说一下无锁算法的基本思想： 要实现无锁（lock-free）的非阻塞算法有多种实现方法，其中 CAS（比较与交换，Compare and swap） 是一种有名的无锁算法。CAS, CPU指令，在大多数处理器架构，包括IA32、Space中采用的都是CAS指令，CAS的语义是“我认为V的值应该为A，如果是，那么将V的
ReetrantLock Synchronized Atomic的性能对比
connect_me的博客
06-22 648
之前看到了一篇帖子关于Lock和Synchronized的性能，写的是Lock比Synchronized的性能要好，可是，我试了下，结果却不是这样的，我所使用的JDK的版本是1.7，可能跟原帖作者用的JDK版本不一样，JDK对Synchronized做了优化。
Synchronized和Atomic性能测试
bo_Wen_h的博客
04-09 275
**** 注意，该测试并不严谨，在赋值操作时测试代码中的方式不同，所以该测试作为定性分析 测试结果为，Synchronized在800ms左右完成了10000次加法，AtomicInteger在700ms左右完成，略胜一筹 import java.util.concurrent.atomic.AtomicInteger; public class Main { public stat...
synchronize、 lock、 Atomic原子性对比
八点二十四分
09-25 787
synchronize：不可中断锁，适合竞争不激烈，可读性好 lock：可中断锁，多样化同步，竞争激烈时能维持常态 Atomic：竞争激烈时能维持常态，比lock性能好；只能同步一个值...
并发--性能调优（一） Synchronized Lock Atomic类比较
进阶的小程媛儿
05-28 677
性能调优 互斥技术。 Synchronized Lock Atomic类比较 Synchronized 和Lock简单性能测试 package com21并发1; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Created by Panda...
简单了解synchronized和lock的区别
08-25
了解synchronized和lock的区别 synchronized是Java语言...在Java中，synchronized和lock都是用于实现线程同步的机制，但它们有不同的实现机制和性能特点。在选择使用哪种机制时，需要考虑到具体的应用场景和性能要求。
ReentrantLock、synchronized与Atomic：性能对比与使用场景解析
本文主要探讨了Java中三种常用的同步机制：`Lock`、`synchronized`和`Semaphore`，特别是通过比较它们在并发环境下的性能差异，以及各自适用的场景。 首先，`synchronized`关键字是Java中实现线程同步的基础机制，...
写一个 java 无锁并发代码 不使用Atomic、synchronized和Lock
最新发布
07-13
下面是一个示例，演示了如何在Java中实现无锁并发代码，而不使用Atomic、synchronized和Lock。 ```java public class NoLockConcurrencyExample { private static volatile int counter = 0; public static void...
synchronized和AtomicXXX效率比较
地球上的葱~
04-27 1242
在Java中，i++和++i都是xian线程不安全的，如果要用十个线程累加一个资源，就会出现错误。synchronized和Atomic是实现线程安全常用方法。而二者效率问题孰优孰劣？ 本着规律符合任意情况原则，简单写了一个测试代码： public class AtomicTest { int count = 0; AtomicInteger count1 = new Atomic...
一次对于synchronized和Lock两种锁的性能测试和比较
weixin_41644977的博客
09-23 1115
对于这两种锁，在jdk1.6之前synchronized的性能是远不如Lock的，因为synchronized需要调用操作系统的函数，操作内核来完成，比较费时，在JDK1.6以后Oracle公司对synchronized进行了大量优化，而synchronized也从重量级的锁采用了CAS的方式编程了JVM级别的锁，性能得到了大大的跃升，才普遍使用JDK1.8的现在，出于好奇，我简单测试了下sync...
Android 价值千万java多线程同步 <四> synchronized&Lock&Atomic6种方式
深南大盗的博客
03-27 967
1）.Android 价值千万 java线程专题：Wait&amp;notify&amp;join&amp;Yield http://blog.csdn.net/whb20081815/article/details/65627387 2).Android 价值千万 java多线程同步 &lt;二&gt;Callable和Future&amp;FutureTask http:...
JAVA多线程同步：volatile,synchronized,Atomic... 比较
wwHRestarting的博客
07-05 420
1. Atomic..系列的对象属于 java.util.concurrent.atomic包 在多线程程序中，能保证对该对象的操作的原子性，常用在需要做递增、递减操作的变量，如计数器。 2. volatile 能保证所修饰的变量的在并发状态下的可见性，但无法保证原子性。 ps: 可见性是指，多个线程之间，总能看到变量的最新值。 原子性是，针对变量的读--改--写操作
java synchronized atomic_synchronized与atomic性能对比
weixin_39534978的博客
03-04 132
写了两个例子，对这两种机制进行对比，发现性能差距在6倍以上。synchronized的例子：public class SyncInc {public static void main(String[] args) {CountDownLatch latch = new CountDownLatch(10);long begin = System.nanoTime();for (int i = 0;...
各种同步方法性能比较（synchronized,ReentrantLock,Atomic）
公众号：Tunky的实用主义
11-27 470
5.0的多线程任务包对于同步的性能方面有了很大的改进，在原有synchronized关键字的基础上，又增加了ReentrantLock，以及各种Atomic类。了解其性能的优劣程度，有助与我们在特定的情形下做出正确的选择。 总体的结论先摆出来： synchronized： 在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序...
使用Synchronized和Atomic控制并发对比
窗外的羊
08-19 705
按照我们往常的经验，我们看到多线程就可能习惯性地将Synchonized往上怼，Synchronized中使用了悲观锁思想，它是可重入锁，实现了多线程的原子性、可见性保证了线程安全，但是有些场景下使用Atomic原子类往往会取得更好的效果，因为Atomic原子类使用的是CAS无锁机制，更加高效地帮助我们实现多线程并发工作，下面是两个代码对比，看到执行结果，你可能会大吃一惊！ 目录 一、Synchronized实现多线程并发 二、使用AtomicInteger原子类实现多线程并发 三、效果对比 一、
Atomic、volatile、synchronized、ThreadLocal优缺点比较
wang123459的博客
01-11 2451
1.Atomic AtomicInteger、AtomicLong、AtomicBoolean、AtomicReference CAS机制只实现单个变量原子操作 Synchronized从偏向锁到轻量级锁再到重量级锁的过度。 compare and swap：比较并替换 CAS机制使用了3个基本操作数，内存值V，旧的预期值A，要修改的新值B Synchronized属于悲观锁，CAS属
多线程：保持原子性的变量AtomicInteger(效率高于synchronized)
baidu_36415076的博客
01-08 1688
import java.util.concurrent.atomic.AtomicInteger;/** * volatile不具备synchronized关键字的原子性（同步） * AtomicInteger具备原子性（同步） */ public class VolatileNoAtomic extends Thread{ //private static volatile int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值