    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.MathIllegalArgumentException;
    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.DescriptiveStatistics} 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: SynchronizedDescriptiveStatistics.java 1416643 2012-12-03 19:37:14Z tn $
    035     */
    036    public class SynchronizedDescriptiveStatistics extends DescriptiveStatistics {
    037
    038        /** Serialization UID */
    039        private static final long serialVersionUID = 1L;
    040
    041        /**
    042         * Construct an instance with infinite window
    043         */
    044        public SynchronizedDescriptiveStatistics() {
    045            // no try-catch or advertized IAE because arg is valid
    046            this(INFINITE_WINDOW);
    047        }
    048
    049        /**
    050         * Construct an instance with finite window
    051         * @param window the finite window size.
    052         * @throws MathIllegalArgumentException if window size is less than 1 but
    053         * not equal to {@link #INFINITE_WINDOW}
    054         */
    055        public SynchronizedDescriptiveStatistics(int window) throws MathIllegalArgumentException {
    056            super(window);
    057        }
    058
    059        /**
    060         * A copy constructor. Creates a deep-copy of the {@code original}.
    061         *
    062         * @param original the {@code SynchronizedDescriptiveStatistics} instance to copy
    063         * @throws NullArgumentException if original is null
    064         */
    065        public SynchronizedDescriptiveStatistics(SynchronizedDescriptiveStatistics original)
    066        throws NullArgumentException {
    067            copy(original, this);
    068        }
    069
    070        /**
    071         * {@inheritDoc}
    072         */
    073        @Override
    074        public synchronized void addValue(double v) {
    075            super.addValue(v);
    076        }
    077
    078        /**
    079         * {@inheritDoc}
    080         */
    081        @Override
    082        public synchronized double apply(UnivariateStatistic stat) {
    083            return super.apply(stat);
    084        }
    085
    086        /**
    087         * {@inheritDoc}
    088         */
    089        @Override
    090        public synchronized void clear() {
    091            super.clear();
    092        }
    093
    094        /**
    095         * {@inheritDoc}
    096         */
    097        @Override
    098        public synchronized double getElement(int index) {
    099            return super.getElement(index);
    100        }
    101
    102        /**
    103         * {@inheritDoc}
    104         */
    105        @Override
    106        public synchronized long getN() {
    107            return super.getN();
    108        }
    109
    110        /**
    111         * {@inheritDoc}
    112         */
    113        @Override
    114        public synchronized double getStandardDeviation() {
    115            return super.getStandardDeviation();
    116        }
    117
    118        /**
    119         * {@inheritDoc}
    120         */
    121        @Override
    122        public synchronized double[] getValues() {
    123            return super.getValues();
    124        }
    125
    126        /**
    127         * {@inheritDoc}
    128         */
    129        @Override
    130        public synchronized int getWindowSize() {
    131            return super.getWindowSize();
    132        }
    133
    134        /**
    135         * {@inheritDoc}
    136         */
    137        @Override
    138        public synchronized void setWindowSize(int windowSize) throws MathIllegalArgumentException {
    139            super.setWindowSize(windowSize);
    140        }
    141
    142        /**
    143         * {@inheritDoc}
    144         */
    145        @Override
    146        public synchronized String toString() {
    147            return super.toString();
    148        }
    149
    150        /**
    151         * Returns a copy of this SynchronizedDescriptiveStatistics instance with the
    152         * same internal state.
    153         *
    154         * @return a copy of this
    155         */
    156        @Override
    157        public synchronized SynchronizedDescriptiveStatistics copy() {
    158            SynchronizedDescriptiveStatistics result =
    159                new SynchronizedDescriptiveStatistics();
    160            // No try-catch or advertised exception because arguments are guaranteed non-null
    161            copy(this, result);
    162            return result;
    163        }
    164
    165        /**
    166         * Copies source to dest.
    167         * <p>Neither source nor dest can be null.</p>
    168         * <p>Acquires synchronization lock on source, then dest before copying.</p>
    169         *
    170         * @param source SynchronizedDescriptiveStatistics to copy
    171         * @param dest SynchronizedDescriptiveStatistics to copy to
    172         * @throws NullArgumentException if either source or dest is null
    173         */
    174        public static void copy(SynchronizedDescriptiveStatistics source,
    175                                SynchronizedDescriptiveStatistics dest)
    176            throws NullArgumentException {
    177            MathUtils.checkNotNull(source);
    178            MathUtils.checkNotNull(dest);
    179            synchronized (source) {
    180                synchronized (dest) {
    181                    DescriptiveStatistics.copy(source, dest);
    182                }
    183            }
    184        }
    185    }