Gleichzeitige Funktionen

*D*

Hallo,

kann mir mal einer erklären, wie man Funktionen gleichzeitig ablaufen lässt.
Ich wäre für ein einfaches Beispiel sehr dankbar.

Schon mal Danke im Voraus.

KPC

Hi, das geht nur mit Threads und die sind Betriebssystem abhängig. Du musst uns also verraten welches du hast, dann wirst du in das entsprechende Forum verschoben. Einfach ist das übrigens nicht, weil man schnell undefiniertes Verhalten erntet!

http://www.kharchi.de/threads.html

*D*

Ich habe Windows 98

The-Kenny

Die Boost-Bibliotheken laufen soweit ich weiß auch unter Windows 98...

WinAPI geht wohl auch mit Windows 98

*D*

Ich habe jetzt versucht die Boost Bibliotthek runter zu laden. Hat auch alles gut funktioniert. Dann hieß es ich brauche Visual C++ 7.0 oder 8.0. als ich das runter geladen hab hieß es dann ich brauche Windows 2000 oder besser!!!

Was soll ich jetzt machen ???

WinAPI

Braunstein

boost::thread funktioniert durchaus auch mit anderen Compilern als Microsofts eigene. Insbesondere g++ sollte doch auch unter Win98 funktionieren.

Hier, nimm den Code:

.h

/*********************************************************
 * File   : dtThread.h 
 * Author : D. Gentner                
 * Date   : 2007/10/20                    
 * Purpose: Multithreading for our DLL
 * Todo   :      
 *
 * Copyright (C) 2007 D. Gentner. All rights reserved.
 * Released under the GNU General Public License V3.
 *********************************************************/
#ifndef _DTTHREAD_H_
#define _DTTHREAD_H_

#include "dtObject.h"
#include "dtMutex.h"

//title: dtThread.h

////////////////////////////////////////////////////
//     Enum: eThreadFlag
//     
//     Provides an Interface for dtThread.
//
//     See Also:
//     <dtThread> for usage.
////////////////////////////////////////////////////  
enum eThreadFlag
{
    /* const: dtThreadNormal */        
    dtThreadNormal = 0x00000000,
    /* const: dtThreadSuspended */
    dtThreadSuspended = 0x00000004,
};

////////////////////////////////////////////////////
//     Class: dtThreadSignal   
//     
//     Provides an Interface for dtThread.
//
//     See Also:
//     <dtThread> for usage.
////////////////////////////////////////////////////  
class DIESELTOOLEXPORT dtThreadSignal : public dtObject
{
public:

    /*   Function: void onThreadExecution(  )   
     *     
     *   Derived Classes must implement this Method.
     *   This method will be called everytime the Thread
     *   executes.
     */
    virtual void onThreadExecution() = 0;
};

////////////////////////////////////////////////////
//     Typedef: dtThreadFlag   
//     
//     Describes a Thread Flag.
//     See Also: <eThreadFlag> for Values.
////////////////////////////////////////////////////  
typedef eThreadFlag dtThreadFlag;

////////////////////////////////////////////////////
//     Typedef: dtThreadHandle   
//     
//     The Handle of a Thread
////////////////////////////////////////////////////  
typedef HANDLE      dtThreadHandle;

////////////////////////////////////////////////////
// Class: dtThread   
//  
// The basic usage of this class is very easy.
// Derive a class from dtThreadSignal and implement
// the Method it provides as abstract member. 
// This method will be called when the thread runs.
////////////////////////////////////////////////////      
class DIESELTOOLEXPORT dtThread : public dtObject
{
public:
    dtThread();
    ~dtThread();

    /***************************************************
     * Function: void connect( dtThreadSignal* sig )
     *   
     * Paramter:
     *  sig - A pointer to a class derived from dtThreadSignal
     ***************************************************/
    void connect( dtThreadSignal* sig );

    /***************************************************
     * Function: bool create( const dtThreadFlag f )   
     *     
     * If you pass dtThreadSuspended as parameter, the thread will start 
     * paused, so you need to call dtThread::resume(), before the Thread
     * begins to cycle. Before you start a Thread you must connect the Signal-Class.
     * You also cannot change the Signal while the Thread is running.
     *     
     *   Parameter:
     *
     *    f - dtThreadSuspended or dtThreadNormal
     *
     *   Return:
     *
     *   * true  All ok
     *   * false Thread wasn't created.
    /***************************************************/
    bool create(const dtThreadFlag f);

    /***************************************************
     * Function: bool resume(  )   
     *    
     * Resumes a paused Thread.
     *     
     * Return:
     *    * true if the Thread was resumed.
     *    * False if the Thread was not paused or not resumed.
    /***************************************************/
    bool resume();

    /***************************************************
     * Function: void sleep( const ULONG mili )   
     *    
     * Sends the Thread to sleep. You can resume it with
     * calling dtThread::resume().
     *     
     * Parameter:
     *
     *  mili - The time to sleep in miliseconds.
    /***************************************************/
    void sleep(const dtULong mili);

    /***************************************************
     * Function: bool stop(  )   
     *    
     * Stops the Thread completly. You must recreate it,
     * if you call this method.
     *     
     * Return:
     *   * true if the thread was stopped.
     *   * false if the thread was not stopped.
    /***************************************************/
    bool stop();

    /***************************************************
     * Function: void setExitCode( const dtExitCode v )   
     *    
     * Sets the desired Exitcode of the Thread.
     *     
     * Parameter:
     *
     *    v - The value of the Exitcode. Defaults to dtSuccess.
     *
    /***************************************************/
    inline void setExitCode(const dtExitCode v){m_exitcode = v;}

    /***************************************************
     * Function: bool isRunning(  )   
     *    
     * Returns true as long as the Thread is Running.
     * 
    /***************************************************/
    inline bool isRunning()const{return m_running;}

private:       
    // Members     
    bool            m_running;
    dtExitCode      m_exitcode;
    dtThreadSignal* m_signal;
    dtThreadHandle  m_thread;

    // friends
    friend DWORD __stdcall ThreadFunc( dtThread* instance );

    // not copyable
    dtNonCopyAble(dtThread);

    // Methods
    inline dtExitCode getExitCode(){return m_exitcode;}
}; 

#endif /* _DTTHREAD_H_ */

.cpp

/*********************************************************
 * File   : dtThread.cpp 
 * Author : D. Gentner                
 * Date   : 2007/10/20                    
 * Purpose: Multithreading for our DLL
 * Todo   :      
 *
 * Copyright (C) 2007 D. Gentner. All rights reserved.
 * Released under the GNU General Public License V3.
 *********************************************************/
#include <DieselTool.h>

// The Thread Method
DWORD __stdcall ThreadFunc( dtThread* instance )
{
    while (instance->isRunning())
    {
        if (instance->m_signal != NULL)
        {
            instance->m_signal->onThreadExecution();
        }        
        Sleep(0);
    }
    return instance->getExitCode();
}

dtThread::dtThread()
{
    m_running = false;
    m_exitcode= dtExitSuccess;
    m_thread  = 0;
}

dtThread::~dtThread()
{
    if (m_thread)
    {
        CloseHandle(m_thread);
    }
}

void dtThread::connect( dtThreadSignal* sig )
{
    if (!m_running)
    {
        m_signal = sig;
    }
}

bool dtThread::create(const dtThreadFlag f)
{   
    if (!m_signal)
    {
        return false;
    }
    if (m_running)
    {   
        return true;
    }

    m_thread = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, this, f, NULL);

    if (m_thread)
    {
        m_running = true;
    }

    return m_running;
}

bool dtThread::resume()
{
    if(::ResumeThread(m_thread) == -1)
        return false;
    return true;
}

bool dtThread::stop()
{
    if (m_thread)
    {
        m_running = false;
    }
    return true;
}

void dtThread::sleep(const dtULong mili)
{
    if (m_running)
    {
        ::SuspendThread(m_thread);
    }
}

Damit kannst du recht einfach einen Thread erstellen.
Erstelle dir eine eigene Klasse, leite sie von dtThreadSignal ab und implementiere die Funktion die da drinsteht. Das ist dann deine Threadfunktion.
HTH
rya.

hustbaer

Also Boost.Thread sollte mit dem VC6 schon noch übersetzen.
Falls die Version 1.34 streikt einfach die 1.33 versuchen.

@Scorcher24: Der Code ist grausam, sowas solltest du nicht posten. Nix synchronisiert, sleep macht kein sleep sondern ein suspend (und was hat suspend bitte in einer Thread-Klasse verloren?) etc.

Und dann noch "General Public License V3"!?! Ich nehme an du meinst die GNU GPLv3. Und GPL Code hier mit den Worten "hier, nimm das" zu posten ist schon irgendwie sehr unverschämt. Ich meine klar, hat ja jeder Lust seine Programme auch unter GPL zu stellen.

Ich überleg gerade ob das ein Trollversuch ist und ich mit Fisch werfen soll, aber ich nehm das mal ernst was du da schreibst.

Mag sein, dass der Code nicht irgendwelchen internationalen Standards entspricht, aber es ist funktionierender Code. Die Synchronisierung is noch nicht ganz fertig, richtig. Aber es ist ein Beispiel, das dem TE evtl. weiterhilft. Und wenn Ihm die GPL nicht passt, dann braucht ers nicht nehmen. Welche Lizenz ich für meinen Code nehme, darf dir egal sein, denn _ich_ bin der Urheber, nicht du.
Aber um dich zu beruhigen hab ich noch ein GNU davor geschrieben...

Und was heisst hier überhaupt frechheit? Ich glaube, du solltest mal deine Ausdrucksweise etwas überdenken. Nicht jeder ist studierter Informatiker. Trotzdem funktioniert das Beispiel. Als Hilfe ist es zu gebrauchen, zumindest lenkts Ihn in der MSDN mal auf die richtige Spur.
Und ich fang jetzt mal nicht davon an, wie schwachsinnig es ist nem Anfänger Boost zu empfehlen.

Scorcher24 schrieb:

Und ich fang jetzt mal nicht davon an, wie schwachsinnig es ist nem Anfänger Boost zu empfehlen.

Würde mich jetzt schon interessieren

The-Kenny

Scorcher24 schrieb:

Und ich fang jetzt mal nicht davon an, wie schwachsinnig es ist nem Anfänger Boost zu empfehlen.

Ich finde es ist garnicht verkehrt, einem Anfänger direkt Boost ans Herz zu legen.

Man versteht zwar mit Sicherheit nicht alles direkt, und es drängen sich sicher eine Menge Fragen auf, aber auf Dauer wird es einem das Zusammenleben mit C++ doch signifikant erleichtern.

The-Kenny schrieb:

Scorcher24 schrieb:

Und ich fang jetzt mal nicht davon an, wie schwachsinnig es ist nem Anfänger Boost zu empfehlen.

Ich finde es ist garnicht verkehrt, einem Anfänger direkt Boost ans Herz zu legen.

Man versteht zwar mit Sicherheit nicht alles direkt, und es drängen sich sicher eine Menge Fragen auf, aber auf Dauer wird es einem das Zusammenleben mit C++ doch signifikant erleichtern.

Hmm, ja aber der TE hat in einem anderen Thread im Graphikforum ja nichtmal gewusst, was er mit der glut.h und glut.lib anfangen soll (was ich nicht kritisiere). Ich finde trotzdem Boost für pure Anfänger ist wirklich übertrieben. Alleine das basteln der Boost-Libs ist nicht ganz so einfach für so jemand.
Aber auch egal.
rya.

hustbaer

@Scorcher24:
???

Sonst alles klar bei dir?

The-Kenny schrieb:

Scorcher24 schrieb:

Und ich fang jetzt mal nicht davon an, wie schwachsinnig es ist nem Anfänger Boost zu empfehlen.

Ich finde es ist garnicht verkehrt, einem Anfänger direkt Boost ans Herz zu legen.

klar, wenn er schnell die lust am programmieren verlieren soll.