FINÁLNÍ VÝPRODEJ KREDITŮ na ITnetwork je tady. Využij poslední šanci a získej až 80 % extra kreditů ZDARMA na náš interaktivní e-learning. Zjisti více:
NOVINKA: Kurz kybernetické bezpečnosti s akreditací MŠMT, nyní již od 0 Kč. Staň se žádaným profesionálem. Zjisti více:
Avatar
Aleš Kryl
Člen
Avatar
Aleš Kryl:17.10.2016 21:30

Prosím o radu zdejší zkušené programátory. Jak by jste realizovali následující ?
Představte si máte milion instancí jedné třídy. Tyto instance leží v nějaké struktuře. Metoda v pravidelném intervalu (milisekundy) navýší integer atribut o 1. Po sem snadné. Zároveň bych ale chtěl, aby metoda aktivovala časovač jako kdyby uvnitř instance, po jeho uplynutí by se atribut opět inkrementoval. Navíc by interval, každé instanci dávala jiný. Dá se to realizovat rozumným způsobem ?

 
Odpovědět
17.10.2016 21:30
Avatar
Lubor Pešek
Člen
Avatar
Lubor Pešek:18.10.2016 9:26

odpověď
Ano dá se to realizovat a je to dost časté využití multithreadingu. Každá instance bude obsahovat své vlastní vlákno, které bude vykonávat časovač. Ten si můžeš klidně v každé instanci nastavit dejme tomu na nějaký základ (třeba 1000 milisekund) + random integer (třeba random od 0 - 1000 dalších milisekund) a máš v každé instanci jiný delay. No a vůbec nepotřebuješ nějakou globální časomíru - jen zesynchronizuješ ta vlákna a půjdou ti hezky postupně. V nějakém for-each cyklu budeš tahat ty instance z nějaké kolekce a u každé spustíš metodu start()

poznámka
ale místo věty:

Po sem snadné.

bys mohl postnout své řešení, které se jen doplní o stávající problém. Jako sorry, ale uznej sám, že nemůžeme plnit domácí úkoly všech škol od A do Z. Tu a tam se najde aktivista, ale takový způsob je na po čuni - ukaž snahu a máš tu tucet zájemců o pomoc;)
Hoď sem co máš a dokončíme to nějak;)

Nahoru Odpovědět
18.10.2016 9:26
Existují dva způsoby, jak vyřešit problém. Za prvé vyhoďte počítač z okna. Za druhé vyhoďte okna z počítače.
Avatar
Lubor Pešek
Člen
Avatar
Odpovídá na Aleš Kryl
Lubor Pešek:18.10.2016 20:19

hmm tak zkusím teda zaimprovizovat -> myslels něco takovéhoto?

import java.util.ArrayList;
import java.util.Random;

public class InstancesCreator {
//###################-ATRIBUTES-##################
//=========CONSTANT ATRIBUTES CLASSES==========
//=========VARIABLES ATRIBUTES CLASSES=========
//=========CONSTANT ATRIBUTES INSTANCE=========

    private final ArrayList<Instance> collectionContainedInstances = new ArrayList<>();
    private final Random rnd = new Random();
//========VARIABLES ATRIBUTES INSTANCE=========
    private Instance instance;
//####################-STATIC-####################
//=============STATIC CONSTRUKTOR==============
//============STATIC ACCES METHODS=============
//===============STATIC METHODS================
//=================MAIN METHOD=================

    public static void main(String[] args) {
        new InstancesCreator();
    }
//###################-INSTANCE-###################
//=================CONSTRUCTOR=================

    public InstancesCreator() {
        createInstances(1000000);
        startIt();
    }
//================ACCES METHODS================
//===================METHODS====================

    public void createInstances(int countOfInstances) {
        int i = 0;
        while (i < countOfInstances) {
            instance = new Instance();
            instance.setName(String.valueOf(i));
            collectionContainedInstances.add(instance);
            i++;
        }
    }

    public void startIt() {

        collectionContainedInstances.stream().forEach((i) -> {
            i.start();
            i.join();
        });
    }
//###############-PRIVATE METHODS-################
//=====PRIVATE STATIC AND SUPPORT METHODS======
//=========PRIVATE AND SUPPORT METHODS=========
//#############-PRIVATE CONSTRUCORS-##############
//===============PRIVATE CLASSES===============

    private class Instance implements Runnable {

        private String name;
        private Thread thread;
        private int delayTime = 5;

        @Override
        public void run() {
            try {
                delayTime += rnd.nextInt(5);
                System.out.println(String.format("############# Instance %s  #############\nstarted!", getName()));
                Thread.sleep(delayTime);
                System.out.println(String.format("finished after %s time delay\n", delayTime));
            } catch (InterruptedException exp) {

            }
        }

        public void start() {
            if (thread == null || !thread.isAlive()) {
                thread = new Thread(this);
                thread.start();
            }
        }

        public void setName(String instancesName) {
            name = instancesName;
        }

        public String getName() {
            return name;
        }

        public void join() {
            try {
                thread.join();
            } catch (InterruptedException ex) {
            }
        }
    }
//===============TESTING METHODS===============
}

Počítej ale s tím, že když tam dáš jako já aspoň těch 5 milisekund delay u každého, tak ti to bude trvat cca 1 a půl hodiny, než to může nejdřív zkončit;)

Editováno
Nahoru Odpovědět
18.10.2016 20:19
Existují dva způsoby, jak vyřešit problém. Za prvé vyhoďte počítač z okna. Za druhé vyhoďte okna z počítače.
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 3 zpráv z 3.