2 w3812127 w3812127 于 2016.04.26 02:04 提问

java编程四线第二十一章 线程SynchronizationComparisons.java有错误

//BaseLine 和AtomicTest 是线程不安全的 ,求解答

//: concurrency/SynchronizationComparisons.java
// Comparing the performance of explicit Locks
// and Atomics versus the synchronized keyword.
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import java.util.*;
import static net.mindview.util.Print.*;

abstract class Accumulator {
public static long cycles = 50000L;
// Number of Modifiers and Readers during each test:
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 {
// Load the array of random numbers:
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 {
public void run() {
for(long 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;
public void run() {
for(long 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();
} catch(Exception e) {
throw new RuntimeException(e);
}
duration = System.nanoTime() - start;
printf("%-13s: %13d\n", id, duration);
}
public static void
report(Accumulator acc1, Accumulator acc2) {
printf("%-22s: %.2f\n", acc1.id + "/" + acc2.id,
(double)acc1.duration/(double)acc2.duration);
}
}

class BaseLine extends Accumulator {
{ id = "BaseLine"; }
public void accumulate() {
value += preLoaded[index++];
if(index >= SIZE) index = 0;
}
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();
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() {
// Oops! Relying on more than one Atomic at
// a time doesn't work. But it still gives us
// a performance indicator:
int i = index.getAndIncrement();
value.getAndAdd(preLoaded[i]);
if(++i >= SIZE)
index.set(0);
}
public long read() { return value.get(); }
}

public class SynchronizationComparisons {
static BaseLine baseLine = new BaseLine();
static SynchronizedTest synch = new SynchronizedTest();
static LockTest lock = new LockTest();
static AtomicTest atomic = new AtomicTest();
static void test() {
print("============================");
printf("%-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; // Default
if(args.length > 0) // Optionally change iterations
iterations = new Integer(args[0]);
// The first time fills the thread pool:
print("Warmup");
baseLine.timedTest();
// Now the initial test doesn't include the cost
// of starting the threads for the first time.
// Produce multiple data points:
for(int i = 0; i < iterations; i++) {
test();
Accumulator.cycles = 2;
}
Accumulator.exec.shutdown();
}
} /
Output: (Sample)
Warmup

BaseLine : 34237033

Cycles : 50000
BaseLine : 20966632
synchronized : 24326555
Lock : 53669950
Atomic : 30552487
synchronized/BaseLine : 1.16
Lock/BaseLine : 2.56
Atomic/BaseLine : 1.46
synchronized/Lock : 0.45
synchronized/Atomic : 0.79

Lock/Atomic : 1.76

Cycles : 100000
BaseLine : 41512818
synchronized : 43843003
Lock : 87430386
Atomic : 51892350
synchronized/BaseLine : 1.06
Lock/BaseLine : 2.11
Atomic/BaseLine : 1.25
synchronized/Lock : 0.50
synchronized/Atomic : 0.84

Lock/Atomic : 1.68

Cycles : 200000
BaseLine : 80176670
synchronized : 5455046661
Lock : 177686829
Atomic : 101789194
synchronized/BaseLine : 68.04
Lock/BaseLine : 2.22
Atomic/BaseLine : 1.27
synchronized/Lock : 30.70
synchronized/Atomic : 53.59

Lock/Atomic : 1.75

Cycles : 400000
BaseLine : 160383513
synchronized : 780052493
Lock : 362187652
Atomic : 202030984
synchronized/BaseLine : 4.86
Lock/BaseLine : 2.26
Atomic/BaseLine : 1.26
synchronized/Lock : 2.15
synchronized/Atomic : 3.86

Lock/Atomic : 1.79

Cycles : 800000
BaseLine : 322064955
synchronized : 336155014
Lock : 704615531
Atomic : 393231542
synchronized/BaseLine : 1.04
Lock/BaseLine : 2.19
Atomic/BaseLine : 1.22
synchronized/Lock : 0.47
synchronized/Atomic : 0.85

Lock/Atomic : 1.79

Cycles : 1600000
BaseLine : 650004120
synchronized : 52235762925
Lock : 1419602771
Atomic : 796950171
synchronized/BaseLine : 80.36
Lock/BaseLine : 2.18
Atomic/BaseLine : 1.23
synchronized/Lock : 36.80
synchronized/Atomic : 65.54

Lock/Atomic : 1.78

Cycles : 3200000
BaseLine : 1285664519
synchronized : 96336767661
Lock : 2846988654
Atomic : 1590545726
synchronized/BaseLine : 74.93
Lock/BaseLine : 2.21
Atomic/BaseLine : 1.24
synchronized/Lock : 33.84
synchronized/Atomic : 60.57
Lock/Atomic : 1.79
*///:~

2个回答

devmiao
devmiao   Ds   Rxr 2016.04.26 05:24
w3812127
w3812127 呵呵,BaseLine 和AtomicTest种 int i处和 index++处非原子操作,有8个线程同时操作,引起混乱。最终引起数组越界。
大约 2 年之前 回复
CSDNXIAOD
CSDNXIAOD   2016.04.27 14:22

JAVA学习笔记之四线程层次结构
----------------------biu~biu~biu~~~在下问答机器人小D,这是我依靠自己的聪明才智给出的答案,如果不正确,你来咬我啊!

Csdn user default icon
上传中...
上传图片
插入图片
准确详细的回答,更有利于被提问者采纳,从而获得C币。复制、灌水、广告等回答会被删除,是时候展现真正的技术了!
其他相关推荐
《java编程思想》第二十一章 并发
Thread.yield():对线程调度器(Java线程机制的一部分,可以将CPU从一个线程转移给另一个线程)的一种建议,它是在说“我已经执行完生命期中最重要的部分了,此刻正是切换给其他任务执行一段时间的大好时机”,即对线程的一种让步,暂停当前正在执行的线程,并执行其他线程。   >>>使用Executor Java.util.concurrent包中的执行器(Executor)将为你管理T
<java编程思想>(thing in java) 阅读笔记(第十六章至第二十一章)
第16章数组  数组与其他种类的容器之间的区别有三方面:效率、类型和保存基本类型的能力。 在java中,数组是一种效率最高的存储和随机访问对象引用序列的方式。数组就是一个简单的线性序列,这使得元素访问非常快速。但是为这种速度所发出的代价是数组对象的大小被固定,并且在其生命周期中不可改变。 数组之所以优于泛型之前的容器,就是因为你可以创建一个数组去持有某种具体类型。这意味着你可以通过编译期检查
java编程 ---线程
0、相关概念理解 1、线程的组成以及线程的创建、启动和调度 2、线程的基本控制 3、选择创建线程的方法 4、使用Java技术中的 synchronized 关键字 5、线程交互 —wait 与 notify 6、线程同步
java编程线程
帮助你更加了解java
第二十一章
孔德之容,惟道是从。道之为物,惟恍惟惚。惚兮恍兮,其中有象;恍兮惚兮,其中有物;窈兮冥兮,其中有精,其精甚真,其中有信,自今及古,其名不去,以阅众甫。吾何以知众甫之状哉?以此 
关于二线和四线的基本概念
电话用户通话时,从电话机传送到程控交换机的信号是模拟信号,程控交换机经PSTN传送的是PCM信号。对端程控交换机把PCM信号还原为模拟信号,再送到对端用户电话机。用户话机送出的话音模拟信号沿二线双向传送,而PCM数字信号双向传送,发送、接收是分开的,需四线传输。所以,程控交换机中有二/四线转换器,也叫二/四线混合电路。  所谓“二线”,指的是传输过程中只使用一对线;如果考虑到光纤通信,则相
四线触摸屏原理
四线触摸屏原理         人机对话的界面种类有很多,比如显示器、LED、LCD及带触摸屏的LCD等。其中后者是最近几年刚发展起来的一项新技术,它通过计算机技术处理声音、图像、视频、文字、动画等信息,并在这些信息间建立一定的逻辑关系,使之成为能交互地进行信息存取和输出的集成系统。换言之,它能综合信息发布者的意愿和接受者对信息的需求及接受习惯,对信息进行收集、加工、整合并双向式传播。触摸屏系统
RS232四线和两线的烦恼
平时我们用串口通信,一般只会用到RXD和TXD两条线;CTS和RTS这两条一般我们不用。毕设要做的东西和串口关系很大,最近在用tiny210开发板和GPRS模块通过串口通信,抓狂的现象出现了,两块板子单独都能和电脑串口助手通信,但是互相就是不能通信,还一直以为自己写的程序有问题,后面一想绝对是协议出了问题。果然啊,把GPRS模块的串口RXD和TXD单独引出来接在电脑上的话,不能和电脑通信。这下明了
两相四线步进电机的驱动
说明:STM32、L298、TB6612、步进电机。 一:L298驱动步进电机 1.关于L298 原理:电机驱动模块内部有H桥的电路,包括4个三极管和1个电机,要使电机运转,必须导通对角线上的一对三极管。根据不同三极管对的导通情况,电流可能会从左至右或从右至左流过电机,从而控制电机的转向。 内部电路 内部电路旨在理解双h桥电路。 由图可知,L298内部两个双H桥电路分别由4个NPN三极管
jlink-swd四线连接
-