001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.math.stat.descriptive; 018 019 /** 020 * Implementation of 021 * {@link org.apache.commons.math.stat.descriptive.DescriptiveStatistics} that 022 * is safe to use in a multithreaded environment. Multiple threads can safely 023 * operate on a single instance without causing runtime exceptions due to race 024 * conditions. In effect, this implementation makes modification and access 025 * methods atomic operations for a single instance. That is to say, as one 026 * thread is computing a statistic from the instance, no other thread can modify 027 * the instance nor compute another statistic. 028 * 029 * @since 1.2 030 * @version $Revision: 762087 $ $Date: 2009-04-05 10:20:18 -0400 (Sun, 05 Apr 2009) $ 031 */ 032 public class SynchronizedDescriptiveStatistics extends DescriptiveStatistics { 033 034 /** Serialization UID */ 035 private static final long serialVersionUID = 1L; 036 037 /** 038 * Construct an instance with infinite window 039 */ 040 public SynchronizedDescriptiveStatistics() { 041 this(INFINITE_WINDOW); 042 } 043 044 /** 045 * Construct an instance with finite window 046 * @param window the finite window size. 047 */ 048 public SynchronizedDescriptiveStatistics(int window) { 049 super(window); 050 } 051 052 /** 053 * A copy constructor. Creates a deep-copy of the {@code original}. 054 * 055 * @param original the {@code SynchronizedDescriptiveStatistics} instance to copy 056 */ 057 public SynchronizedDescriptiveStatistics(SynchronizedDescriptiveStatistics original) { 058 copy(original, this); 059 } 060 061 /** 062 * {@inheritDoc} 063 */ 064 @Override 065 public synchronized void addValue(double v) { 066 super.addValue(v); 067 } 068 069 /** 070 * {@inheritDoc} 071 */ 072 @Override 073 public synchronized double apply(UnivariateStatistic stat) { 074 return super.apply(stat); 075 } 076 077 /** 078 * {@inheritDoc} 079 */ 080 @Override 081 public synchronized void clear() { 082 super.clear(); 083 } 084 085 /** 086 * {@inheritDoc} 087 */ 088 @Override 089 public synchronized double getElement(int index) { 090 return super.getElement(index); 091 } 092 093 /** 094 * {@inheritDoc} 095 */ 096 @Override 097 public synchronized long getN() { 098 return super.getN(); 099 } 100 101 /** 102 * {@inheritDoc} 103 */ 104 @Override 105 public synchronized double getStandardDeviation() { 106 return super.getStandardDeviation(); 107 } 108 109 /** 110 * {@inheritDoc} 111 */ 112 @Override 113 public synchronized double[] getValues() { 114 return super.getValues(); 115 } 116 117 /** 118 * {@inheritDoc} 119 */ 120 @Override 121 public synchronized int getWindowSize() { 122 return super.getWindowSize(); 123 } 124 125 /** 126 * {@inheritDoc} 127 */ 128 @Override 129 public synchronized void setWindowSize(int windowSize) { 130 super.setWindowSize(windowSize); 131 } 132 133 /** 134 * {@inheritDoc} 135 */ 136 @Override 137 public synchronized String toString() { 138 return super.toString(); 139 } 140 141 /** 142 * Returns a copy of this SynchronizedDescriptiveStatistics instance with the 143 * same internal state. 144 * 145 * @return a copy of this 146 */ 147 @Override 148 public synchronized SynchronizedDescriptiveStatistics copy() { 149 SynchronizedDescriptiveStatistics result = 150 new SynchronizedDescriptiveStatistics(); 151 copy(this, result); 152 return result; 153 } 154 155 /** 156 * Copies source to dest. 157 * <p>Neither source nor dest can be null.</p> 158 * <p>Acquires synchronization lock on source, then dest before copying.</p> 159 * 160 * @param source SynchronizedDescriptiveStatistics to copy 161 * @param dest SynchronizedDescriptiveStatistics to copy to 162 * @throws NullPointerException if either source or dest is null 163 */ 164 public static void copy(SynchronizedDescriptiveStatistics source, 165 SynchronizedDescriptiveStatistics dest) { 166 synchronized (source) { 167 synchronized (dest) { 168 DescriptiveStatistics.copy(source, dest); 169 } 170 } 171 } 172 }