JAVA并发,同步锁性能测试

测试主要从运行时间差来体现,数据量越大,时间差越明显,例子如下:

 1 package com.xt.thinks21_2;
 2
 3 /**
 4  * 同步锁性能测试
 5  *
 6  * @author Administrator
 7  *
 8  */
 9 public class SynchronizedTimeTest {
10     public volatile int inc = 0;
11
12     public void increase() {
13         inc++;
14     }
15
16     public static void main(String[] args) {
17         final SynchronizedTimeTest test = new SynchronizedTimeTest();
18         for (int i = 0; i < 10; i++) {
19             new Thread() {
20                 public void run() {
21                     for (int j = 0; j < 10000; j++)
22                         test.increase();
23                 };
24             }.start();
25         }
26         Long time1 = System.currentTimeMillis();
27         while (Thread.activeCount() > 1) {
28             // 保证前面的线程都执行完
29             Thread.yield();
30         }
31         Long time2 = System.currentTimeMillis();
32         System.out.println("time1:" + time1 + " time2:" + time2);
33         Long timeDiff = time2 - time1;
34         System.out.println("time:" + timeDiff + "-->" + test.inc);
35     }
36 }

上面是方法未加synchronized运行结果:

time1:1429805281187 time2:1429805281187
time:0-->75809

方法添加synchronized运行结果:

time1:1429805416628 time2:1429805416645
time:17-->100000

时间: 2024-10-07 06:38:50

JAVA并发,同步锁性能测试的相关文章

java并发 lock锁

Java并发编程:Lock 在上一篇文章中我们讲到了如何使用关键字synchronized来实现同步访问.本文我们继续来探讨这个问题,从Java 5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock. 也许有朋友会问,既然都可以通过synchronized来实现同步访问了,那么为什么还需要提供Lock?这个问题将在下面进行阐述.本文先从synchronized的缺陷讲起,然后再讲述java.util.concurrent.locks包

java 并发(六) --- 锁

      阅读前阅读以下参考资料,文章图片或代码部分来自与参考资料 概览 一张图了解一下java锁. 各种锁 为什么要设置锁的等级 jdk1.6对锁的实现引入了大量的优化,如自旋锁.适应性自旋锁.锁消除.锁粗化.偏向锁.轻量级锁等技术来减少锁操作的开销.锁主要存在四中状态,依次是:无锁状态.偏向锁状态.轻量级锁状态.重量级锁状态,他们会随着竞争的激烈而逐渐升级.注意锁可以升级不可降级,这种策略是为了提高获得锁和释放锁的效率. 乐观锁和悲观锁 阅读这篇文章,了解乐观锁和悲观锁 ---- 不可不说

Java多线程同步锁的理解

ava 多线程中同步锁的主要通过synchronized的关键字来实现的.让我们从一个买票程序说起吧. package com.day04; /** * * @author Administrator 问题描述:使用多线程的方式来模拟多个窗口买票 * */ public class SaleWindow implements Runnable { // 初始化票数10 private int ticket = 10; @Override public void run() { // 获取线程的名

java并发-同步容器类

java平台类库包含了丰富的并发基础构建模块,如线程安全的容器类以及各种用于协调多个相互协作的线程控制流的同步工具类. 同步容器类 同步容器类包括Vector和Hashtable,是早期JDK的一部分,此外还有Collections.synchronizedXXX等工厂方法创建的.这些类实现安全的方式是,将他们的状态封装起来,并对每个public方法进行同步,从而 使得每次只有一个线程能访问容器的状态. 同步容器类都是线程安全的,但是对于某些复合操作需要额外的加锁来保护.常见复合操作有:迭代(反

(转)java并发对象锁、类锁、私有锁

转自:http://ifeve.com/java-locks/ 建议参考:http://www.zhihu.com/question/28113814 Java类锁和对象锁实践 感谢[jiehao]同学的投稿,投稿可将文章发送到[email protected] 类锁和对象锁是否会冲突?对象锁和私有锁是否会冲突?通过实例来进行说明. 一.相关约定 为了明确后文的描述,先对本文涉及到的锁的相关定义作如下约定: 1. 类锁:在代码中的方法上加了static和synchronized的锁,或者sync

java并发库--锁

synchronized的缺陷: 被synchronized修饰了,当一个线程获取了对应的锁,并执行该代码块时,其他线程便只能一直等待,等待获取锁的线程释放锁,获取线程被阻塞时,没有释放锁会导致等待线程无期限的等待下去.另外,多个线程都只是进行读操作时,线程之间不会发生冲突,通过Lock就可以办到.Lock还可以知道线程有没有成功获取到锁. Lock和synchronized的比较 1)Lock不是Java语言内置的,synchronized是Java语言的关键字,因此是内置特性.Lock是一个

java并发-独占锁与共享锁

1 锁的独占与共享 java并发包提供的加锁模式分为独占锁和共享锁,独占锁模式下,每次只能有一个线程能持有锁,ReentrantLock就是以独占方式实现的互斥锁.共享锁,则允许多个线程同时获取锁,并发访问 共享资源,如:ReadWriteLock.AQS的内部类Node定义了两个常量SHARED和EXCLUSIVE,他们分别标识 AQS队列中等待线程的锁获取模式. 很显然,独占锁是一种悲观保守的加锁策略,它避免了读/读冲突,如果某个只读线程获取锁,则其他读线程都只能等待,这种情况下就限制了不必

Java 并发同步器之CountDownLatch、CyclicBarrier

一.简介 1.CountDownLatch是一个同步计数器,构造时传入int参数,该参数就是计数器的初始值,每调用一次countDown()方法,计数器减1,计数器大于0 时,await()方法会阻塞程序的执行. CountDownLatch可以看作是一个倒计数的锁存器,当计数减至0时触发特定的事件.利用这种特性,可以让主线程等待子线程的结束. CountDownLatch最重要的方法是countDown()和await(),前者主要是倒数一次,后者是等待倒数到0,如果没有到达0,就只有阻塞等待

2015.6.10(java并发)

今天复习熟悉了Java并发的一些概念. 程序:系统要完成的一个任务,就是一个程序: 进程:每个运行中的程序就是一个进程,Windows任务管理器上可以看到每一个进程,Linux下使用ps –e命令可以查看当前运行的所有进程: 线程:每个运行的程序(进程)内部可能会包含多个顺序执行流,每个执行流就可以看做线程. 1. 进程的特性: 1) 独立性:进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,其他进程不能访问这个进程空间内的数据. 2) 动态性:进程与程序的