synchronized 与 Lock 性能比较

最新推荐文章于 2024-04-01 14:35:56 发布
最新推荐文章于 2024-04-01 14:35:56 发布
阅读量727 收藏 2
点赞数 2
分类专栏： concurrent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kaishizhangcheng/article/details/103360473
版权

synchronized 与 Lock 性能比较

JDK1.8

D:\soft\Java\jdk1.8.0_172\bin\java.exe "-javaagent:D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\lib\idea_rt.jar=57167:D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\bin" -Dfile.encoding=UTF-8 -classpath "D:\soft\Java\jdk1.8.0_172\jre\lib\charsets.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\deploy.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\access-bridge-64.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\cldrdata.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\dnsns.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\jaccess.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\jfxrt.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\localedata.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\nashorn.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\sunec.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\sunjce_provider.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\sunmscapi.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\sunpkcs11.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\ext\zipfs.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\javaws.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\jce.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\jfr.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\jfxswt.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\jsse.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\management-agent.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\plugin.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\resources.jar;D:\soft\Java\jdk1.8.0_172\jre\lib\rt.jar;D:\myworkspace\03mygithub\MyThread\bin;D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\lib\junit-4.12.jar;D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\lib\hamcrest-core-1.3.jar" com.zc.concurrent.issue.ReentrantLockVsSynchronizedTest
-------------------------------------
// 线程数1,每个线程循环 100000 次
3789172(elapse), testLongAdder: result=100000, threadCount=1, loopCount=100000
6642633(elapse), testReentrantLockUnfair: result=100000, threadCount=1, loopCount=100000
6841152(elapse), testReentrantLockFair: result=100000, threadCount=1, loopCount=100000
8382098(elapse), testSynchronized: result=100000, threadCount=1, loopCount=100000
44980066(elapse), testAtomicInteger: result=100000, threadCount=1, loopCount=100000
-------------------------------------
// 线程数2,每个线程循环 100000 次
2647611(elapse), testLongAdder: result=300000, threadCount=2, loopCount=100000
3772457(elapse), testAtomicInteger: result=300000, threadCount=2, loopCount=100000
5013131(elapse), testSynchronized: result=300000, threadCount=2, loopCount=100000
5831547(elapse), testReentrantLockFair: result=300000, threadCount=2, loopCount=100000
9820412(elapse), testReentrantLockUnfair: result=300000, threadCount=2, loopCount=100000
-------------------------------------
// 线程数4,每个线程循环 100000 次
2838213(elapse), testSynchronized: result=700000, threadCount=4, loopCount=100000
3695923(elapse), testAtomicInteger: result=700000, threadCount=4, loopCount=100000
12967987(elapse), testLongAdder: result=700000, threadCount=4, loopCount=100000
13843291(elapse), testReentrantLockUnfair: result=700000, threadCount=4, loopCount=100000
1132170308(elapse), testReentrantLockFair: result=700000, threadCount=4, loopCount=100000
-------------------------------------
// 线程数6,每个线程循环 100000 次
2340008(elapse), testLongAdder: result=1300000, threadCount=6, loopCount=100000
5598133(elapse), testSynchronized: result=1300000, threadCount=6, loopCount=100000
11595358(elapse), testAtomicInteger: result=1300000, threadCount=6, loopCount=100000
17305800(elapse), testReentrantLockUnfair: result=1300000, threadCount=6, loopCount=100000
1706668497(elapse), testReentrantLockFair: result=1300000, threadCount=6, loopCount=100000
-------------------------------------
// 线程数8,每个线程循环 100000 次
2604212(elapse), testLongAdder: result=2100000, threadCount=8, loopCount=100000
7267222(elapse), testSynchronized: result=2100000, threadCount=8, loopCount=100000
15585101(elapse), testAtomicInteger: result=2100000, threadCount=8, loopCount=100000
20813467(elapse), testReentrantLockUnfair: result=2100000, threadCount=8, loopCount=100000
2392860159(elapse), testReentrantLockFair: result=2100000, threadCount=8, loopCount=100000
-------------------------------------
// 线程数10,每个线程循环 100000 次
6970763(elapse), testLongAdder: result=3100000, threadCount=10, loopCount=100000
9930961(elapse), testSynchronized: result=3100000, threadCount=10, loopCount=100000
20397367(elapse), testAtomicInteger: result=3100000, threadCount=10, loopCount=100000
25850936(elapse), testReentrantLockUnfair: result=3100000, threadCount=10, loopCount=100000
2794116491(elapse), testReentrantLockFair: result=3100000, threadCount=10, loopCount=100000
-------------------------------------
// 线程数50,每个线程循环 100000 次
14844099(elapse), testLongAdder: result=8100000, threadCount=50, loopCount=100000
47918859(elapse), testSynchronized: result=8100000, threadCount=50, loopCount=100000
98661562(elapse), testAtomicInteger: result=8100000, threadCount=50, loopCount=100000
126939598(elapse), testReentrantLockUnfair: result=8100000, threadCount=50, loopCount=100000
14410074177(elapse), testReentrantLockFair: result=8100000, threadCount=50, loopCount=100000
-------------------------------------
// 线程数100,每个线程循环 100000 次
29294384(elapse), testLongAdder: result=18100000, threadCount=100, loopCount=100000
90143110(elapse), testSynchronized: result=18100000, threadCount=100, loopCount=100000
193961488(elapse), testAtomicInteger: result=18100000, threadCount=100, loopCount=100000
244101889(elapse), testReentrantLockUnfair: result=18100000, threadCount=100, loopCount=100000
31166365222(elapse), testReentrantLockFair: result=18100000, threadCount=100, loopCount=100000
-------------------------------------
// 线程数200,每个线程循环 100000 次
69702637(elapse), testLongAdder: result=38100000, threadCount=200, loopCount=100000
170973104(elapse), testSynchronized: result=38100000, threadCount=200, loopCount=100000
341206964(elapse), testAtomicInteger: result=38100000, threadCount=200, loopCount=100000
489087584(elapse), testReentrantLockUnfair: result=38100000, threadCount=200, loopCount=100000
63709112896(elapse), testReentrantLockFair: result=38100000, threadCount=200, loopCount=100000
-------------------------------------
// 线程数500,每个线程循环 100000 次
133355267(elapse), testLongAdder: result=88100000, threadCount=500, loopCount=100000
465237384(elapse), testSynchronized: result=88100000, threadCount=500, loopCount=100000
982221507(elapse), testAtomicInteger: result=88100000, threadCount=500, loopCount=100000
1246923387(elapse), testReentrantLockUnfair: result=88100000, threadCount=500, loopCount=100000
163173197284(elapse), testReentrantLockFair: result=88100000, threadCount=500, loopCount=100000
-------------------------------------
-------------------------------------
// 线程数500,每个线程循环 10000 次
46909254(elapse), testSynchronized: result=93100000, threadCount=500, loopCount=10000
53434593(elapse), testLongAdder: result=93100000, threadCount=500, loopCount=10000
76151149(elapse), testAtomicInteger: result=93100000, threadCount=500, loopCount=10000
115951527(elapse), testReentrantLockUnfair: result=93100000, threadCount=500, loopCount=10000
16067416290(elapse), testReentrantLockFair: result=93100000, threadCount=500, loopCount=10000
-------------------------------------
// 线程数500,每个线程循环 1000 次
21785245(elapse), testLongAdder: result=93600000, threadCount=500, loopCount=1000
22926219(elapse), testSynchronized: result=93600000, threadCount=500, loopCount=1000
23726455(elapse), testAtomicInteger: result=93600000, threadCount=500, loopCount=1000
23893305(elapse), testReentrantLockUnfair: result=93600000, threadCount=500, loopCount=1000
1583798403(elapse), testReentrantLockFair: result=93600000, threadCount=500, loopCount=1000
-------------------------------------
// 线程数500,每个线程循环 100 次
21886704(elapse), testSynchronized: result=93650000, threadCount=500, loopCount=100
22070561(elapse), testReentrantLockUnfair: result=93650000, threadCount=500, loopCount=100
22847925(elapse), testLongAdder: result=93650000, threadCount=500, loopCount=100
24225539(elapse), testAtomicInteger: result=93650000, threadCount=500, loopCount=100
133848487(elapse), testReentrantLockFair: result=93650000, threadCount=500, loopCount=100
-------------------------------------
// 线程数500,每个线程循环 10 次
20742504(elapse), testSynchronized: result=93655000, threadCount=500, loopCount=10
21348326(elapse), testLongAdder: result=93655000, threadCount=500, loopCount=10
21286160(elapse), testReentrantLockUnfair: result=93655000, threadCount=500, loopCount=10
21943591(elapse), testAtomicInteger: result=93655000, threadCount=500, loopCount=10
22087863(elapse), testReentrantLockFair: result=93655000, threadCount=500, loopCount=10
-------------------------------------
// 线程数500,每个线程循环 1 次
20936918(elapse), testReentrantLockUnfair: result=93655500, threadCount=500, loopCount=1
21259769(elapse), testAtomicInteger: result=93655500, threadCount=500, loopCount=1
21328093(elapse), testLongAdder: result=93655500, threadCount=500, loopCount=1
22007810(elapse), testSynchronized: result=93655500, threadCount=500, loopCount=1
23318273(elapse), testReentrantLockFair: result=93655500, threadCount=500, loopCount=1
-------------------------------------
// 线程数1000,每个线程循环 1 次
53460398(elapse), testLongAdder: result=1500, threadCount=1000, loopCount=1
58974079(elapse), testAtomicInteger: result=1500, threadCount=1000, loopCount=1
82545706(elapse), testSynchronized: result=1500, threadCount=1000, loopCount=1
130621152(elapse), testReentrantLockFair: result=1500, threadCount=1000, loopCount=1
200410000(elapse), testReentrantLockUnfair: result=1500, threadCount=1000, loopCount=1
-------------------------------------
// 线程数1500,每个线程循环 1 次
84837038(elapse), testSynchronized: result=3000, threadCount=1500, loopCount=1
104347079(elapse), testAtomicInteger: result=3000, threadCount=1500, loopCount=1
109697722(elapse), testReentrantLockUnfair: result=3000, threadCount=1500, loopCount=1
138776874(elapse), testReentrantLockFair: result=3000, threadCount=1500, loopCount=1
212777150(elapse), testLongAdder: result=3000, threadCount=1500, loopCount=1
-------------------------------------

Process finished with exit code 0

从上面的测试数据能看出来,在JDK1.8下synchronized 比 ReentrantLock 性能要好很多,从上面数据来看正常能快个3~5倍这样.

ReentrantLock 公平模式性能很差,并发竞争大的情况下,从数据看 正常比 非公平模式能慢两个数量级.

AtomicInteger 和 LongAdder 在这种场景下性能还是比 ReentrantLock 要好一些的.

JDK1.7

D:\soft\Java\JDK1.7\bin\java.exe "-javaagent:D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\lib\idea_rt.jar=60620:D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\bin" -Dfile.encoding=UTF-8 -classpath D:\soft\Java\JDK1.7\jre\lib\charsets.jar;D:\soft\Java\JDK1.7\jre\lib\deploy.jar;D:\soft\Java\JDK1.7\jre\lib\ext\access-bridge-64.jar;D:\soft\Java\JDK1.7\jre\lib\ext\dnsns.jar;D:\soft\Java\JDK1.7\jre\lib\ext\jaccess.jar;D:\soft\Java\JDK1.7\jre\lib\ext\localedata.jar;D:\soft\Java\JDK1.7\jre\lib\ext\sunec.jar;D:\soft\Java\JDK1.7\jre\lib\ext\sunjce_provider.jar;D:\soft\Java\JDK1.7\jre\lib\ext\sunmscapi.jar;D:\soft\Java\JDK1.7\jre\lib\ext\zipfs.jar;D:\soft\Java\JDK1.7\jre\lib\javaws.jar;D:\soft\Java\JDK1.7\jre\lib\jce.jar;D:\soft\Java\JDK1.7\jre\lib\jfr.jar;D:\soft\Java\JDK1.7\jre\lib\jfxrt.jar;D:\soft\Java\JDK1.7\jre\lib\jsse.jar;D:\soft\Java\JDK1.7\jre\lib\management-agent.jar;D:\soft\Java\JDK1.7\jre\lib\plugin.jar;D:\soft\Java\JDK1.7\jre\lib\resources.jar;D:\soft\Java\JDK1.7\jre\lib\rt.jar;D:\myworkspace\02localdemo\T03TomLoader\target\classes com.zc.test.ReentrantLockVsSynchronizedTest
-------------------------------------
// 线程数1,每个线程循环 100000 次
22840888(elapse), testSynchronized: result=100000, threadCount=1, loopCount=100000
26080245(elapse), testAtomicInteger: result=100000, threadCount=1, loopCount=100000
8243398(elapse), testReentrantLockUnfair: result=100000, threadCount=1, loopCount=100000
-------------------------------------
// 线程数2,每个线程循环 100000 次
5484065(elapse), testSynchronized: result=300000, threadCount=2, loopCount=100000
5490809(elapse), testAtomicInteger: result=300000, threadCount=2, loopCount=100000
11825254(elapse), testReentrantLockUnfair: result=300000, threadCount=2, loopCount=100000
-------------------------------------
// 线程数4,每个线程循环 100000 次
11477771(elapse), testSynchronized: result=700000, threadCount=4, loopCount=100000
15624982(elapse), testReentrantLockUnfair: result=700000, threadCount=4, loopCount=100000
29080910(elapse), testAtomicInteger: result=700000, threadCount=4, loopCount=100000
-------------------------------------
// 线程数6,每个线程循环 100000 次
15473673(elapse), testSynchronized: result=1300000, threadCount=6, loopCount=100000
32343434(elapse), testAtomicInteger: result=1300000, threadCount=6, loopCount=100000
35170504(elapse), testReentrantLockUnfair: result=1300000, threadCount=6, loopCount=100000
-------------------------------------
// 线程数8,每个线程循环 100000 次
18780768(elapse), testSynchronized: result=2100000, threadCount=8, loopCount=100000
19249649(elapse), testReentrantLockUnfair: result=2100000, threadCount=8, loopCount=100000
51532676(elapse), testAtomicInteger: result=2100000, threadCount=8, loopCount=100000
-------------------------------------
// 线程数10,每个线程循环 100000 次
22142404(elapse), testReentrantLockUnfair: result=3100000, threadCount=10, loopCount=100000
28116170(elapse), testSynchronized: result=3100000, threadCount=10, loopCount=100000
46799583(elapse), testAtomicInteger: result=3100000, threadCount=10, loopCount=100000
-------------------------------------
// 线程数50,每个线程循环 100000 次
154866338(elapse), testReentrantLockUnfair: result=8100000, threadCount=50, loopCount=100000
164094417(elapse), testSynchronized: result=8100000, threadCount=50, loopCount=100000
190372008(elapse), testAtomicInteger: result=8100000, threadCount=50, loopCount=100000
-------------------------------------
// 线程数100,每个线程循环 100000 次
320082668(elapse), testSynchronized: result=18100000, threadCount=100, loopCount=100000
399773154(elapse), testAtomicInteger: result=18100000, threadCount=100, loopCount=100000
669262375(elapse), testReentrantLockUnfair: result=18100000, threadCount=100, loopCount=100000
-------------------------------------
// 线程数200,每个线程循环 100000 次
557621097(elapse), testReentrantLockUnfair: result=38100000, threadCount=200, loopCount=100000
650982745(elapse), testSynchronized: result=38100000, threadCount=200, loopCount=100000
1287148955(elapse), testAtomicInteger: result=38100000, threadCount=200, loopCount=100000
-------------------------------------
// 线程数500,每个线程循环 100000 次
1319411162(elapse), testReentrantLockUnfair: result=88100000, threadCount=500, loopCount=100000
1496867673(elapse), testSynchronized: result=88100000, threadCount=500, loopCount=100000
2878890484(elapse), testAtomicInteger: result=88100000, threadCount=500, loopCount=100000
-------------------------------------
// 线程数500,每个线程循环 10000 次
134509730(elapse), testReentrantLockUnfair: result=93100000, threadCount=500, loopCount=10000
170702742(elapse), testSynchronized: result=93100000, threadCount=500, loopCount=10000
250160106(elapse), testAtomicInteger: result=93100000, threadCount=500, loopCount=10000
-------------------------------------
// 线程数500,每个线程循环 1000 次
27824108(elapse), testReentrantLockUnfair: result=93600000, threadCount=500, loopCount=1000
40523787(elapse), testSynchronized: result=93600000, threadCount=500, loopCount=1000
40963344(elapse), testAtomicInteger: result=93600000, threadCount=500, loopCount=1000
-------------------------------------
// 线程数500,每个线程循环 100 次
24163960(elapse), testSynchronized: result=93650000, threadCount=500, loopCount=100
24996452(elapse), testAtomicInteger: result=93650000, threadCount=500, loopCount=100
35085760(elapse), testReentrantLockUnfair: result=93650000, threadCount=500, loopCount=100
-------------------------------------
// 线程数500,每个线程循环 10 次
40494463(elapse), testReentrantLockUnfair: result=93655000, threadCount=500, loopCount=10
51199269(elapse), testSynchronized: result=93655000, threadCount=500, loopCount=10
52468973(elapse), testAtomicInteger: result=93655000, threadCount=500, loopCount=10
-------------------------------------
// 线程数500,每个线程循环 1 次
44156664(elapse), testAtomicInteger: result=93655500, threadCount=500, loopCount=1
46565583(elapse), testSynchronized: result=93655500, threadCount=500, loopCount=1
144862068(elapse), testReentrantLockUnfair: result=93655500, threadCount=500, loopCount=1
-------------------------------------
// 线程数1000,每个线程循环 1 次
111706963(elapse), testReentrantLockUnfair: result=93656500, threadCount=1000, loopCount=1
156553607(elapse), testAtomicInteger: result=93656500, threadCount=1000, loopCount=1
182228017(elapse), testSynchronized: result=93656500, threadCount=1000, loopCount=1
-------------------------------------
// 线程数1500,每个线程循环 1 次
176627244(elapse), testSynchronized: result=93658000, threadCount=1500, loopCount=1
202298721(elapse), testAtomicInteger: result=93658000, threadCount=1500, loopCount=1
69693840(elapse), testReentrantLockUnfair: result=93658000, threadCount=1500, loopCount=1
-------------------------------------

Process finished with exit code 0

从数据上看,正常情况下还是 synchronized 稍微快一点的.有比 ReentrantLock(非公平)慢的时候,最多也就慢一倍这样.

JDK1.6

D:\soft\Java\jdk1.6.0_45\bin\java.exe "-javaagent:D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\lib\idea_rt.jar=61893:D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\bin" -Dfile.encoding=UTF-8 -classpath D:\soft\Java\jdk1.6.0_45\jre\lib\charsets.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\deploy.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\ext\dnsns.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\ext\localedata.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\ext\sunjce_provider.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\ext\sunmscapi.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\javaws.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\jce.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\jsse.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\management-agent.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\plugin.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\resources.jar;D:\soft\Java\jdk1.6.0_45\jre\lib\rt.jar;D:\myworkspace\02localdemo\T03TomLoader\target\classes com.zc.test.ReentrantLockVsSynchronizedTest
-------------------------------------
// 线程数1,每个线程循环 100000 次
4767108(elapse), testAtomicInteger: result=100000, threadCount=1, loopCount=100000
5231298(elapse), testSynchronized: result=100000, threadCount=1, loopCount=100000
11269281(elapse), testReentrantLockUnfair: result=100000, threadCount=1, loopCount=100000
-------------------------------------
// 线程数2,每个线程循环 100000 次
2265820(elapse), testAtomicInteger: result=300000, threadCount=2, loopCount=100000
5181154(elapse), testSynchronized: result=300000, threadCount=2, loopCount=100000
9388771(elapse), testReentrantLockUnfair: result=300000, threadCount=2, loopCount=100000
-------------------------------------
// 线程数4,每个线程循环 100000 次
10028901(elapse), testSynchronized: result=700000, threadCount=4, loopCount=100000
28028493(elapse), testAtomicInteger: result=700000, threadCount=4, loopCount=100000
9190838(elapse), testReentrantLockUnfair: result=700000, threadCount=4, loopCount=100000
-------------------------------------
// 线程数6,每个线程循环 100000 次
15937569(elapse), testReentrantLockUnfair: result=1300000, threadCount=6, loopCount=100000
17108746(elapse), testSynchronized: result=1300000, threadCount=6, loopCount=100000
21985524(elapse), testAtomicInteger: result=1300000, threadCount=6, loopCount=100000
-------------------------------------
// 线程数8,每个线程循环 100000 次
20291510(elapse), testReentrantLockUnfair: result=2100000, threadCount=8, loopCount=100000
20961550(elapse), testSynchronized: result=2100000, threadCount=8, loopCount=100000
36662479(elapse), testAtomicInteger: result=2100000, threadCount=8, loopCount=100000
-------------------------------------
// 线程数10,每个线程循环 100000 次
21589658(elapse), testAtomicInteger: result=3100000, threadCount=10, loopCount=100000
23756071(elapse), testReentrantLockUnfair: result=3100000, threadCount=10, loopCount=100000
27164038(elapse), testSynchronized: result=3100000, threadCount=10, loopCount=100000
-------------------------------------
// 线程数50,每个线程循环 100000 次
126872447(elapse), testReentrantLockUnfair: result=8100000, threadCount=50, loopCount=100000
149717147(elapse), testSynchronized: result=8100000, threadCount=50, loopCount=100000
296352695(elapse), testAtomicInteger: result=8100000, threadCount=50, loopCount=100000
-------------------------------------
// 线程数100,每个线程循环 100000 次
240213603(elapse), testSynchronized: result=18100000, threadCount=100, loopCount=100000
246687627(elapse), testReentrantLockUnfair: result=18100000, threadCount=100, loopCount=100000
324364767(elapse), testAtomicInteger: result=18100000, threadCount=100, loopCount=100000
-------------------------------------
// 线程数200,每个线程循环 100000 次
522835023(elapse), testReentrantLockUnfair: result=38100000, threadCount=200, loopCount=100000
749915548(elapse), testSynchronized: result=38100000, threadCount=200, loopCount=100000
1348022018(elapse), testAtomicInteger: result=38100000, threadCount=200, loopCount=100000
-------------------------------------
// 线程数500,每个线程循环 100000 次
1252515069(elapse), testReentrantLockUnfair: result=88100000, threadCount=500, loopCount=100000
1796960863(elapse), testSynchronized: result=88100000, threadCount=500, loopCount=100000
3533896401(elapse), testAtomicInteger: result=88100000, threadCount=500, loopCount=100000
-------------------------------------
-------------------------------------
// 线程数500,每个线程循环 10000 次
120825372(elapse), testReentrantLockUnfair: result=93100000, threadCount=500, loopCount=10000
173094359(elapse), testSynchronized: result=93100000, threadCount=500, loopCount=10000
327061935(elapse), testAtomicInteger: result=93100000, threadCount=500, loopCount=10000
-------------------------------------
// 线程数500,每个线程循环 1000 次
25813109(elapse), testReentrantLockUnfair: result=93600000, threadCount=500, loopCount=1000
26570239(elapse), testSynchronized: result=93600000, threadCount=500, loopCount=1000
28246953(elapse), testAtomicInteger: result=93600000, threadCount=500, loopCount=1000
-------------------------------------
// 线程数500,每个线程循环 100 次
25892576(elapse), testReentrantLockUnfair: result=93650000, threadCount=500, loopCount=100
26211908(elapse), testAtomicInteger: result=93650000, threadCount=500, loopCount=100
32821991(elapse), testSynchronized: result=93650000, threadCount=500, loopCount=100
-------------------------------------
// 线程数500,每个线程循环 10 次
24638120(elapse), testAtomicInteger: result=93655000, threadCount=500, loopCount=10
28614668(elapse), testSynchronized: result=93655000, threadCount=500, loopCount=10
28632262(elapse), testReentrantLockUnfair: result=93655000, threadCount=500, loopCount=10
-------------------------------------
// 线程数500,每个线程循环 1 次
28014418(elapse), testAtomicInteger: result=93655500, threadCount=500, loopCount=1
30410727(elapse), testSynchronized: result=93655500, threadCount=500, loopCount=1
37675310(elapse), testReentrantLockUnfair: result=93655500, threadCount=500, loopCount=1
-------------------------------------
// 线程数1000,每个线程循环 1 次
49730166(elapse), testAtomicInteger: result=93656500, threadCount=1000, loopCount=1
54536567(elapse), testSynchronized: result=93656500, threadCount=1000, loopCount=1
55911835(elapse), testReentrantLockUnfair: result=93656500, threadCount=1000, loopCount=1
-------------------------------------
// 线程数1500,每个线程循环 1 次
77436982(elapse), testReentrantLockUnfair: result=93658000, threadCount=1500, loopCount=1
80245284(elapse), testSynchronized: result=93658000, threadCount=1500, loopCount=1
82252179(elapse), testAtomicInteger: result=93658000, threadCount=1500, loopCount=1
-------------------------------------

Process finished with exit code 0

从上面数据看,线程数大于等于6后 ReentrantLockUnfair 快于 synchronized,线程数小的时候 synchronized 快一些.

JDK11

D:\soft\Java\jdk-11.0.4\bin\java.exe -Didea.launcher.port=62514 "-Didea.launcher.bin.path=D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\bin" -Dfile.encoding=UTF-8 -classpath "D:\myworkspace\02localdemo\T03TomLoader\target\classes;D:\soft\JetBrains\IntelliJ IDEA 2018.1.6\lib\idea_rt.jar" com.intellij.rt.execution.application.AppMainV2 com.zc.test.ReentrantLockVsSynchronizedTest
-------------------------------------
// 线程数1,每个线程循环 100000 次
4207617(elapse), testAtomicInteger: result=100000, threadCount=1, loopCount=100000
7003311(elapse), testSynchronized: result=100000, threadCount=1, loopCount=100000
12754512(elapse), testReentrantLockUnfair: result=100000, threadCount=1, loopCount=100000
-------------------------------------
// 线程数2,每个线程循环 100000 次
4266557(elapse), testAtomicInteger: result=300000, threadCount=2, loopCount=100000
6544986(elapse), testSynchronized: result=300000, threadCount=2, loopCount=100000
10791310(elapse), testReentrantLockUnfair: result=300000, threadCount=2, loopCount=100000
-------------------------------------
// 线程数4,每个线程循环 100000 次
7923773(elapse), testAtomicInteger: result=700000, threadCount=4, loopCount=100000
9049499(elapse), testReentrantLockUnfair: result=700000, threadCount=4, loopCount=100000
10100450(elapse), testSynchronized: result=700000, threadCount=4, loopCount=100000
-------------------------------------
// 线程数6,每个线程循环 100000 次
13618380(elapse), testAtomicInteger: result=1300000, threadCount=6, loopCount=100000
14245901(elapse), testReentrantLockUnfair: result=1300000, threadCount=6, loopCount=100000
15905607(elapse), testSynchronized: result=1300000, threadCount=6, loopCount=100000
-------------------------------------
// 线程数8,每个线程循环 100000 次
14097525(elapse), testAtomicInteger: result=2100000, threadCount=8, loopCount=100000
14484007(elapse), testSynchronized: result=2100000, threadCount=8, loopCount=100000
20932226(elapse), testReentrantLockUnfair: result=2100000, threadCount=8, loopCount=100000
-------------------------------------
// 线程数10,每个线程循环 100000 次
9905157(elapse), testAtomicInteger: result=3100000, threadCount=10, loopCount=100000
28208539(elapse), testSynchronized: result=3100000, threadCount=10, loopCount=100000
40982698(elapse), testReentrantLockUnfair: result=3100000, threadCount=10, loopCount=100000
-------------------------------------
// 线程数50,每个线程循环 100000 次
67569652(elapse), testAtomicInteger: result=8100000, threadCount=50, loopCount=100000
119220208(elapse), testReentrantLockUnfair: result=8100000, threadCount=50, loopCount=100000
127837187(elapse), testSynchronized: result=8100000, threadCount=50, loopCount=100000
-------------------------------------
// 线程数100,每个线程循环 100000 次
155161331(elapse), testAtomicInteger: result=18100000, threadCount=100, loopCount=100000
214199043(elapse), testSynchronized: result=18100000, threadCount=100, loopCount=100000
271890809(elapse), testReentrantLockUnfair: result=18100000, threadCount=100, loopCount=100000
-------------------------------------
// 线程数200,每个线程循环 100000 次
346384305(elapse), testAtomicInteger: result=38100000, threadCount=200, loopCount=100000
465400423(elapse), testReentrantLockUnfair: result=38100000, threadCount=200, loopCount=100000
658154372(elapse), testSynchronized: result=38100000, threadCount=200, loopCount=100000
-------------------------------------
// 线程数500,每个线程循环 100000 次
930565965(elapse), testAtomicInteger: result=88100000, threadCount=500, loopCount=100000
1305456443(elapse), testReentrantLockUnfair: result=88100000, threadCount=500, loopCount=100000
1745141403(elapse), testSynchronized: result=88100000, threadCount=500, loopCount=100000
-------------------------------------
-------------------------------------
// 线程数500,每个线程循环 10000 次
88273743(elapse), testAtomicInteger: result=93100000, threadCount=500, loopCount=10000
132994002(elapse), testReentrantLockUnfair: result=93100000, threadCount=500, loopCount=10000
165907776(elapse), testSynchronized: result=93100000, threadCount=500, loopCount=10000
-------------------------------------
// 线程数500,每个线程循环 1000 次
32739299(elapse), testAtomicInteger: result=93600000, threadCount=500, loopCount=1000
34829766(elapse), testSynchronized: result=93600000, threadCount=500, loopCount=1000
37466527(elapse), testReentrantLockUnfair: result=93600000, threadCount=500, loopCount=1000
-------------------------------------
// 线程数500,每个线程循环 100 次
34564096(elapse), testReentrantLockUnfair: result=93650000, threadCount=500, loopCount=100
35123587(elapse), testAtomicInteger: result=93650000, threadCount=500, loopCount=100
40711163(elapse), testSynchronized: result=93650000, threadCount=500, loopCount=100
-------------------------------------
// 线程数500,每个线程循环 10 次
33697882(elapse), testAtomicInteger: result=93655000, threadCount=500, loopCount=10
34600750(elapse), testSynchronized: result=93655000, threadCount=500, loopCount=10
36510584(elapse), testReentrantLockUnfair: result=93655000, threadCount=500, loopCount=10
-------------------------------------
// 线程数500,每个线程循环 1 次
35484557(elapse), testAtomicInteger: result=93655500, threadCount=500, loopCount=1
35623551(elapse), testReentrantLockUnfair: result=93655500, threadCount=500, loopCount=1
36133778(elapse), testSynchronized: result=93655500, threadCount=500, loopCount=1
-------------------------------------
// 线程数1000,每个线程循环 1 次
66762085(elapse), testAtomicInteger: result=93656500, threadCount=1000, loopCount=1
67941473(elapse), testReentrantLockUnfair: result=93656500, threadCount=1000, loopCount=1
74041623(elapse), testSynchronized: result=93656500, threadCount=1000, loopCount=1
-------------------------------------
// 线程数1500,每个线程循环 1 次
98764781(elapse), testReentrantLockUnfair: result=93658000, threadCount=1500, loopCount=1
100622126(elapse), testSynchronized: result=93658000, threadCount=1500, loopCount=1
102833697(elapse), testAtomicInteger: result=93658000, threadCount=1500, loopCount=1
-------------------------------------

Process finished with exit code 0

线程数少的时候还是 synchronized 快,线程数多的时候二者基本持平.

测试使用的代码

package com.zc.concurrent.issue;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
// import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockVsSynchronizedTest {

    public static AtomicInteger a = new AtomicInteger(0);

    // JDK8 才有
    public static LongAdder b = new LongAdder();

    public static int c = 0;

    public static int d = 0;

    public static int e = 0;

    public static final ReentrantLock fairLock = new ReentrantLock(true);

    public static final ReentrantLock unfairLock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        System.out.println("-------------------------------------");
        testAll(1, 100000);

        System.out.println("-------------------------------------");
        testAll(2, 100000);

        System.out.println("-------------------------------------");
        testAll(4, 100000);

        System.out.println("-------------------------------------");
        testAll(6, 100000);

        System.out.println("-------------------------------------");
        testAll(8, 100000);

        System.out.println("-------------------------------------");
        testAll(10, 100000);

        System.out.println("-------------------------------------");
        testAll(50, 100000);

        System.out.println("-------------------------------------");
        testAll(100, 100000);

        System.out.println("-------------------------------------");
        testAll(200, 100000);

        System.out.println("-------------------------------------");
        testAll(500, 100000);

        System.out.println("-------------------------------------");
        testAll(500, 10000);

        System.out.println("-------------------------------------");
        testAll(500, 1000);

        System.out.println("-------------------------------------");
        testAll(500, 100);

        System.out.println("-------------------------------------");
        testAll(500, 10);


        System.out.println("-------------------------------------");
        testAll(500, 1);

        System.out.println("-------------------------------------");
        testAll(1000, 1);

        System.out.println("-------------------------------------");
        testAll(1500, 1);

        System.out.println("-------------------------------------");
    }

    public static void testAll(int threadCount, int loopCount) throws InterruptedException {
        testAtomicInteger(threadCount, loopCount);

        testLongAdder(threadCount, loopCount);

        testSynchronized(threadCount, loopCount);

        testReentrantLockUnfair(threadCount, loopCount);

        testReentrantLockFair(threadCount, loopCount);
    }

    public static void testAtomicInteger(int threadCount, int loopCount) throws InterruptedException {
        long start = System.nanoTime();

        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                for (int j = 0; j < loopCount; j++) {
                    a.incrementAndGet();
                }
                countDownLatch.countDown();
            }).start();
        }

        countDownLatch.await();

        System.out.println((System.nanoTime() - start) + "(elapse), " + "testAtomicInteger: result=" + a.get() + ", threadCount=" + threadCount + ", loopCount=" + loopCount);
    }

    public static void testLongAdder(int threadCount, int loopCount) throws InterruptedException {
        long start = System.nanoTime();

        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                for (int j = 0; j < loopCount; j++) {
                    b.increment();
                }
                countDownLatch.countDown();
            }).start();
        }

        countDownLatch.await();

        System.out.println((System.nanoTime() - start) + "(elapse), " + "testLongAdder: result=" + b.sum() + ", threadCount=" + threadCount + ", loopCount=" + loopCount);
    }

    public static void testReentrantLockFair(int threadCount, int loopCount) throws InterruptedException {
        long start = System.nanoTime();

        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                for (int j = 0; j < loopCount; j++) {
                    fairLock.lock();
                    c++;
                    fairLock.unlock();
                }
                countDownLatch.countDown();
            }).start();
        }

        countDownLatch.await();

        System.out.println((System.nanoTime() - start) + "(elapse), " + "testReentrantLockFair: result=" + c + ", threadCount=" + threadCount + ", loopCount=" + loopCount);
    }

    public static void testReentrantLockUnfair(int threadCount, int loopCount) throws InterruptedException {
        long start = System.nanoTime();

        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                for (int j = 0; j < loopCount; j++) {
                    unfairLock.lock();
                    d++;
                    unfairLock.unlock();
                }
                countDownLatch.countDown();
            }).start();
        }

        countDownLatch.await();

        System.out.println((System.nanoTime() - start) + "(elapse), " + "testReentrantLockUnfair: result=" + d + ", threadCount=" + threadCount + ", loopCount=" + loopCount);
    }

    public static void testSynchronized(int threadCount, int loopCount) throws InterruptedException {
        long start = System.nanoTime();

        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                for (int j = 0; j < loopCount; j++) {
                    synchronized (ReentrantLockVsSynchronizedTest.class) {
                        e++;
                    }
                }
                countDownLatch.countDown();
            }).start();
        }

        countDownLatch.await();

        System.out.println((System.nanoTime() - start) + "(elapse), " + "testSynchronized: result=" + e + ", threadCount=" + threadCount + ", loopCount=" + loopCount);
    }
}
FlyingZCC
关注
专栏目录
synchronized 和 ReentrantLock 有什么区别？有人说 synchronized 最慢，这话靠谱吗？
qq_38304320的博客
11-21 563
如果面试问道 synchronized 和 ReentrantLock 有什么区别？有人说 synchronized 最慢，这话靠谱吗？ 你会如何回答呢？ 我的回答 synchronized 是 Java 内建的同步机制，所以也有人称其为 Intrinsic Locking，它提供了互斥的语义和可见性，当一个线程已经获取当前锁时，其他试图获取的线程只能等待或者阻塞在那里。 在 Java 5 以前，synchronized 是仅有的同步手段，在代码中， synchronized 可以用来修饰方法，也可以使
一篇搞懂Synchronized与Lock的区别
最新发布
qq_63772695的博客
04-14 781
以Lock的实现类ReenTranLock来看，当创建ReenTranLock时传入的参数为true是，会创建一个公平锁，查看Sync发现继承了AbstractQueuedSynchronized，这就说明Lock底层使用AQS+CAS来实现的，传入的参数为空或者false则创建非公平锁。首先声明一个ReenTranLock锁和调用newCondition创建条件，然后创建一个线程t1并且尝试获取锁调用条件进入等待，线程t2同理，线程t3，唤醒t1,t2，最后观察控制台。而Lock提供了许多额外的功能。
synchronized与lock之间的性能比较
fxh13579的专栏
01-12 5242
1.关于两者的实现的比较 A).一般认为synchronized关键字的实现是源自于像信号量之类的线程同步机制，涉及到线程运行状态的切换，在高并发状态下，CPU消耗过多的时间在线程的调度上，从而造成了性能的极大浪费。然而真的如此么？  线程的状态主要有一下五种，分别是新建状态，就绪状态，运行状态，阻塞状态，消亡状态等5种状态 B).lock实现原理则是依赖于硬件，现代处理器都
lock和synchronized 对比
weixin_30677617的博客
07-21 263
1、特色：reentainLock 可以维持公平性、响应中断、超时机制 2、性能：并发不严重sync更优，高并发reentainLock好。 3、底层实现：sync和lock 有同步队列、也有等待队列，sync是基于 object 的wait/notify,lock 是基于condition的await/sigal，底层是locksupport.park/unpark。 4、synchron...
synchronized和Lock
qq_51417143的博客
04-01 981
而轻量级锁是在多个线程竞争同一个锁时才会触发，当一个线程尝试获取锁失败时，会自动将锁升级为轻量级锁。其中，写锁和悲观读锁的使用方式类似于读写锁，而乐观读锁是一种不加锁的读取方式，它返回一个"邮戳（stamp）"，表示当前共享数据的版本号，在读取共享数据时需要使用这个邮戳进行验证，以确保数据的一致性。在Synchronized锁升级之前，每个Synchronized锁都是一个重量级锁，它包含了一个互斥量和一个条件变量，当多个线程竞争同一个锁时，会导致不必要的线程上下文切换和内存开销，从而影响程序的性能。
关于synchronized与lock的性能比较
热门推荐
ganyao939543405的博客
09-09 1万+
记得当初看教程的时候大家都说lock性能比好不少，最近需要自己设计一个缓存终于要自己尝试一番了。1.关于两者的实现的比较A).一般认为synchronized关键字的实现是源自于像信号量之类的线程同步机制，涉及到线程运行状态的切换，在高并发状态下，CPU消耗过多的时间在线程的调度上，从而造成了性能的极大浪费。然而真的如此么？ B).lock实现原理则是依赖于硬件，现代处理器都支持CAS指令，所谓C
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
简单了解synchronized和lock的区别
08-25
lock是Java 5中引入的API，用于实现线程同步，主要是为了解决synchronized的性能问题。Lock接口提供了lock、unlock和tryLock等方法，用于控制线程的执行顺序。Lock接口的实现类有ReentrantLock、...
Java中synchronized与Lock的区别与使用
fudaihb的博客
12-04 1754
当我们谈论Java多线程编程时，线程同步是一个避免资源竞争和保证线程安全的关键概念。在Java中，主要有两种机制来实现线程同步：synchronized关键字和Lock接口。这篇博客将详细介绍这两种同步机制的区别和使用方法，并通过示例来加深理解。
Synchronized与Lock
03-30
"Synchronized与Lock"这个主题探讨了两种主要的同步机制：synchronized关键字和Lock接口（包括其实现类如ReentrantLock）。这两种机制都用于实现线程间的互斥访问，但它们在功能、灵活性和性能上有所差异。 首先，...
Java高并发编程实战4，synchronized与Lock底层原理
学Java，找哪吒
09-23 4874
Java高并发编程实战系列，打造精品专栏。
Synchronized与Lock对比分析
itbird的专栏
03-29 268
Synchronized与Lock对比分析 1.Lock是接口，Synchronized是关键字 2.Synchronized可以锁对象、锁方法、锁代码块，Lock只能锁代码块 3.Synchronized锁不需要主动释放，Lock需要在finally中主动释放 4.Synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可） 5.Synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁 ...
synchronized与lock的对比
m0_46406255的博客
01-03 2736
synchronized与lock的对比 Lock是显示锁(手动开启和关闭锁，别忘记关闭锁)，synchronized是隐式锁，出了作用域自动释放 Lock只有代码块锁，synchronized有代码块锁和方法锁 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好地拓展性(提供更多的子类) 优先使用顺序 Lock>同步代码块(已经进入了方法体，分配响应资源)>同步方法(在方法体之外) ...
一次对于synchronized和Lock两种锁的性能测试和比较
weixin_41644977的博客
09-23 1119
对于这两种锁，在jdk1.6之前synchronized的性能是远不如Lock的，因为synchronized需要调用操作系统的函数，操作内核来完成，比较费时，在JDK1.6以后Oracle公司对synchronized进行了大量优化，而synchronized也从重量级的锁采用了CAS的方式编程了JVM级别的锁，性能得到了大大的跃升，才普遍使用JDK1.8的现在，出于好奇，我简单测试了下sync...
java中synchronized和Lock类的效率对比
pouper的博客
07-24 643
java中synchronized和Lock类的效率对比结论两者之间的区别运行对比：赋上测试代码： 结论 先说结论：两者相差非常细微，synchronized偶尔表现稍微优秀一点点 两者之间的区别 两者间的区别大概有： 1、一个是jvm关键字，一个是java类 2、Lock接口提供更多可适配的类和方法，包含非公平锁、读写锁 这些synchronized都提供不了 3、synchronized不用处理异常情况下的锁释放 更多区别参见网友的帖子了， 有很多详细的解释，比如：https://blog.csdn.n
ReentrantLock和synchronized的性能对比
yemou_blog的博客
12-14 2055
详见：http://blog.yemou.net/article/query/info/tytfjhfascvhzxcytpo8 ReentrantLock和内部锁的性能对比     ReentrantLock是jdk5引入的新的锁机制，它与内部锁（synchronize） 相同的并发性和内存语义，比如可重入加锁语义。在中等或者更高负荷下，ReentrantLock有更好的性能，并且拥有可轮询和
Java从入门到放弃32---死锁/ReentrantLock类(可重入锁)/Lock和Synchronized的区别
DOGIOOH的博客
06-05 279
Java从入门到放弃32—死锁/ReentrantLock类(可重入锁)/Lock和Synchronized的区别 01 死锁 多个线程各自占有一些共享资源 , 并且互相等待其他线程占有的资源才能运行 , 而 导致两个或者多个线程都在等待对方释放资源 , 都停止执行的情形 。某一个同步块 同时拥有 “ 两个以上对象的锁 ” 时 , 就可能会发生 “ 死锁 ” 的问题 。 产生死锁的四个必要条件：...
一文教你，synchronized和Lock的区别？
Tom弹架构
05-26 1646
需要完整版面试文档扫描左侧二维码领取！ 最近有多位粉丝被问到synchronized和Lock，据说还是阿里一面的面试题。在分布式开发中，锁是控制线程的重要方式。Java提供了两种锁机制synchronized 和 Lock。接下来，我给大家分享一下我对synchronized和Lock的理解。 另外，我花了1个多星期把往期的面试题解析配套文档准备好了，想获取的小伙伴可以扫描左侧二维码领取！ 1、两者对比 synchronized和Lock都是Java中用来解决线程安全问题的一个工具，那么
Java并发编程大揭秘：synchronized和Lock谁更胜一筹？
孤芳不自赏
04-25 487
这篇文章你值得一阅！讲技术我觉得应该让外行也能看明白，而不是一堆专业术语堆砌，像在读天书一般，到最后感觉云里雾里。
Java编程：synchronized与Lock深度解析与比较
Java编程中的synchronized与lock是两种不同的线程同步机制，它们在处理并发问题时有着各自的优缺点。synchronized是Java语言内置的关键字，主要用于同步控制，当一个代码块被synchronized修饰后，同一时间只有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FlyingZCC

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值