    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.math3.stat.descriptive;
    018
    019    import org.apache.commons.math3.exception.MathIllegalStateException;
    020    import org.apache.commons.math3.exception.NullArgumentException;
    021    import org.apache.commons.math3.util.MathUtils;
    022
    023    /**
    024     * Implementation of
    025     * {@link org.apache.commons.math3.stat.descriptive.SummaryStatistics} that
    026     * is safe to use in a multithreaded environment.  Multiple threads can safely
    027     * operate on a single instance without causing runtime exceptions due to race
    028     * conditions.  In effect, this implementation makes modification and access
    029     * methods atomic operations for a single instance.  That is to say, as one
    030     * thread is computing a statistic from the instance, no other thread can modify
    031     * the instance nor compute another statistic.
    032     *
    033     * @since 1.2
    034     * @version $Id: SynchronizedSummaryStatistics.java 1416643 2012-12-03 19:37:14Z tn $
    035     */
    036    public class SynchronizedSummaryStatistics extends SummaryStatistics {
    037
    038        /** Serialization UID */
    039        private static final long serialVersionUID = 1909861009042253704L;
    040
    041        /**
    042         * Construct a SynchronizedSummaryStatistics instance
    043         */
    044        public SynchronizedSummaryStatistics() {
    045            super();
    046        }
    047
    048        /**
    049         * A copy constructor. Creates a deep-copy of the {@code original}.
    050         *
    051         * @param original the {@code SynchronizedSummaryStatistics} instance to copy
    052         * @throws NullArgumentException if original is null
    053         */
    054        public SynchronizedSummaryStatistics(SynchronizedSummaryStatistics original)
    055        throws NullArgumentException {
    056            copy(original, this);
    057        }
    058
    059        /**
    060         * {@inheritDoc}
    061         */
    062        @Override
    063        public synchronized StatisticalSummary getSummary() {
    064            return super.getSummary();
    065        }
    066
    067        /**
    068         * {@inheritDoc}
    069         */
    070        @Override
    071        public synchronized void addValue(double value) {
    072            super.addValue(value);
    073        }
    074
    075        /**
    076         * {@inheritDoc}
    077         */
    078        @Override
    079        public synchronized long getN() {
    080            return super.getN();
    081        }
    082
    083        /**
    084         * {@inheritDoc}
    085         */
    086        @Override
    087        public synchronized double getSum() {
    088            return super.getSum();
    089        }
    090
    091        /**
    092         * {@inheritDoc}
    093         */
    094        @Override
    095        public synchronized double getSumsq() {
    096            return super.getSumsq();
    097        }
    098
    099        /**
    100         * {@inheritDoc}
    101         */
    102        @Override
    103        public synchronized double getMean() {
    104            return super.getMean();
    105        }
    106
    107        /**
    108         * {@inheritDoc}
    109         */
    110        @Override
    111        public synchronized double getStandardDeviation() {
    112            return super.getStandardDeviation();
    113        }
    114
    115        /**
    116         * {@inheritDoc}
    117         */
    118        @Override
    119        public synchronized double getVariance() {
    120            return super.getVariance();
    121        }
    122
    123        /**
    124         * {@inheritDoc}
    125         */
    126        @Override
    127        public synchronized double getPopulationVariance() {
    128            return super.getPopulationVariance();
    129        }
    130
    131        /**
    132         * {@inheritDoc}
    133         */
    134        @Override
    135        public synchronized double getMax() {
    136            return super.getMax();
    137        }
    138
    139        /**
    140         * {@inheritDoc}
    141         */
    142        @Override
    143        public synchronized double getMin() {
    144            return super.getMin();
    145        }
    146
    147        /**
    148         * {@inheritDoc}
    149         */
    150        @Override
    151        public synchronized double getGeometricMean() {
    152            return super.getGeometricMean();
    153        }
    154
    155        /**
    156         * {@inheritDoc}
    157         */
    158        @Override
    159        public synchronized String toString() {
    160            return super.toString();
    161        }
    162
    163        /**
    164         * {@inheritDoc}
    165         */
    166        @Override
    167        public synchronized void clear() {
    168            super.clear();
    169        }
    170
    171        /**
    172         * {@inheritDoc}
    173         */
    174        @Override
    175        public synchronized boolean equals(Object object) {
    176            return super.equals(object);
    177        }
    178
    179        /**
    180         * {@inheritDoc}
    181         */
    182        @Override
    183        public synchronized int hashCode() {
    184            return super.hashCode();
    185        }
    186
    187        /**
    188         * {@inheritDoc}
    189         */
    190        @Override
    191        public synchronized StorelessUnivariateStatistic getSumImpl() {
    192            return super.getSumImpl();
    193        }
    194
    195        /**
    196         * {@inheritDoc}
    197         */
    198        @Override
    199        public synchronized void setSumImpl(StorelessUnivariateStatistic sumImpl)
    200        throws MathIllegalStateException {
    201            super.setSumImpl(sumImpl);
    202        }
    203
    204        /**
    205         * {@inheritDoc}
    206         */
    207        @Override
    208        public synchronized StorelessUnivariateStatistic getSumsqImpl() {
    209            return super.getSumsqImpl();
    210        }
    211
    212        /**
    213         * {@inheritDoc}
    214         */
    215        @Override
    216        public synchronized void setSumsqImpl(StorelessUnivariateStatistic sumsqImpl)
    217        throws MathIllegalStateException {
    218            super.setSumsqImpl(sumsqImpl);
    219        }
    220
    221        /**
    222         * {@inheritDoc}
    223         */
    224        @Override
    225        public synchronized StorelessUnivariateStatistic getMinImpl() {
    226            return super.getMinImpl();
    227        }
    228
    229        /**
    230         * {@inheritDoc}
    231         */
    232        @Override
    233        public synchronized void setMinImpl(StorelessUnivariateStatistic minImpl)
    234        throws MathIllegalStateException {
    235            super.setMinImpl(minImpl);
    236        }
    237
    238        /**
    239         * {@inheritDoc}
    240         */
    241        @Override
    242        public synchronized StorelessUnivariateStatistic getMaxImpl() {
    243            return super.getMaxImpl();
    244        }
    245
    246        /**
    247         * {@inheritDoc}
    248         */
    249        @Override
    250        public synchronized void setMaxImpl(StorelessUnivariateStatistic maxImpl)
    251        throws MathIllegalStateException {
    252            super.setMaxImpl(maxImpl);
    253        }
    254
    255        /**
    256         * {@inheritDoc}
    257         */
    258        @Override
    259        public synchronized StorelessUnivariateStatistic getSumLogImpl() {
    260            return super.getSumLogImpl();
    261        }
    262
    263        /**
    264         * {@inheritDoc}
    265         */
    266        @Override
    267        public synchronized void setSumLogImpl(StorelessUnivariateStatistic sumLogImpl)
    268        throws MathIllegalStateException {
    269            super.setSumLogImpl(sumLogImpl);
    270        }
    271
    272        /**
    273         * {@inheritDoc}
    274         */
    275        @Override
    276        public synchronized StorelessUnivariateStatistic getGeoMeanImpl() {
    277            return super.getGeoMeanImpl();
    278        }
    279
    280        /**
    281         * {@inheritDoc}
    282         */
    283        @Override
    284        public synchronized void setGeoMeanImpl(StorelessUnivariateStatistic geoMeanImpl)
    285        throws MathIllegalStateException {
    286            super.setGeoMeanImpl(geoMeanImpl);
    287        }
    288
    289        /**
    290         * {@inheritDoc}
    291         */
    292        @Override
    293        public synchronized StorelessUnivariateStatistic getMeanImpl() {
    294            return super.getMeanImpl();
    295        }
    296
    297        /**
    298         * {@inheritDoc}
    299         */
    300        @Override
    301        public synchronized void setMeanImpl(StorelessUnivariateStatistic meanImpl)
    302        throws MathIllegalStateException {
    303            super.setMeanImpl(meanImpl);
    304        }
    305
    306        /**
    307         * {@inheritDoc}
    308         */
    309        @Override
    310        public synchronized StorelessUnivariateStatistic getVarianceImpl() {
    311            return super.getVarianceImpl();
    312        }
    313
    314        /**
    315         * {@inheritDoc}
    316         */
    317        @Override
    318        public synchronized void setVarianceImpl(StorelessUnivariateStatistic varianceImpl)
    319        throws MathIllegalStateException {
    320            super.setVarianceImpl(varianceImpl);
    321        }
    322
    323        /**
    324         * Returns a copy of this SynchronizedSummaryStatistics instance with the
    325         * same internal state.
    326         *
    327         * @return a copy of this
    328         */
    329        @Override
    330        public synchronized SynchronizedSummaryStatistics copy() {
    331            SynchronizedSummaryStatistics result =
    332                new SynchronizedSummaryStatistics();
    333            // No try-catch or advertised exception because arguments are guaranteed non-null
    334            copy(this, result);
    335            return result;
    336        }
    337
    338        /**
    339         * Copies source to dest.
    340         * <p>Neither source nor dest can be null.</p>
    341         * <p>Acquires synchronization lock on source, then dest before copying.</p>
    342         *
    343         * @param source SynchronizedSummaryStatistics to copy
    344         * @param dest SynchronizedSummaryStatistics to copy to
    345         * @throws NullArgumentException if either source or dest is null
    346         */
    347        public static void copy(SynchronizedSummaryStatistics source,
    348                                SynchronizedSummaryStatistics dest)
    349            throws NullArgumentException {
    350            MathUtils.checkNotNull(source);
    351            MathUtils.checkNotNull(dest);
    352            synchronized (source) {
    353                synchronized (dest) {
    354                    SummaryStatistics.copy(source, dest);
    355                }
    356            }
    357        }
    358
    359    }