C#

Christian Graus wrote:

it's not going to run your code twice at the same time

private System.Timers.Timer tt = new System.Timers.Timer ( 1000 ) ;
 
public Template
(
)
{
    tt.Elapsed += F ; 
 
    tt.Start() ;
 
    return ;
}
 
private void
F
(
    object                         sender
,
    System.Timers.ElapsedEventArgs e
)
{
    System.Console.WriteLine ( "Start" ) ;
    System.Threading.Thread.Sleep ( 5000 ) ;
    System.Console.WriteLine ( "Stop" ) ;
 
    return ;
}

Start
Start
Start
Start
Start
Stop
Start
Stop
Start
Start
Stop
Start
Stop
Stop
Start
Stop
Start
Stop
Start
Stop
Start
Stop
Start

George_George wrote:

I think the Timer class is used to perform a task in a regular interval no matter whether or not the previous task is completed or not. So, it is possible to execute two tasks at the same time if the 1st task is not completed in 1 second for some reason. Right?

George_George wrote:

"except that the caller doesn't get blocked if the worker's already busy with a task", any ideas?

N a v a n e e t h wrote:

Yes this is true. Caller won't be blocked. The example uses a queue system. When you enqueue new task, it will be added to the queue and immediately control will be given back. The program then processes each task depending on the availability of worker threads.

George_George wrote:

But the Enqueue operation will be blocked since it is using a lock object to do synchronization, right? Means if worker thread is at the same time Dequeue, the person who Enqueues must wait.

George_George wrote:

Does using event (as showed in the document you referred) has better performance compared with my alternative method?

N a v a n e e t h wrote:

only to dequeue items

public void EnqueueTask (string task) {
  lock (locker) tasks.Enqueue (task);
  wh.Set();
}

N a v a n e e t h wrote:

It won't create much threads for processing each task. It will use the existing threads to spin between the tasks.

N a v a n e e t h wrote:

Will the steps you provided satisfy your requirement ? As I understood from the previous messages, you are trying to execute a task before the previous task completes. I mean you need to execute it in each 1 second without blocking. If it is the case, looks like the steps you provided won't satisfy the requirement.

George_George wrote:

No. When Enqueue, the lock is still used.

George_George wrote:

If I use timer, then each time, the timer will create a new worker thread or reuse previous one?

George_George wrote:

My requirement is to complete the current task before execute next task, and between each task execution iteration, sleep 1 second so that system could have more chances to do other things

N a v a n e e t h wrote:

Either you can do parallel execution or sequential execution. If you need to execute the next only after the completion of first task, then you don't need such a producer/consumer solution.

George_George wrote:

Compared my original solution with using Timer, I think the advantage is I am using a single thread to execute (while Timer will use thread pool, not sure whether it is always the same thread), but disadvantege is I need to call sleep in order to execute next task.

while (false == StopEvent.WaitOne(1000))
{
    // do some regular job
}

George_George wrote:

Could you show me your pseudo code

class Program
{

    static AutoResetEvent CheckEvent = new AutoResetEvent(false);
    static bool stop = false;

    static void ThreadMethod2()
    {
        while (true)
        {
            CheckEvent.WaitOne();
            Console.WriteLine(DateTime.Now);
            if (stop)
            {
                break;
            }
            else
            {
                // do some work
            }
        }
    }

    static void OnTimedEvent(object source, ElapsedEventArgs e)
    {
        CheckEvent.Set();
    }

    static void Main(string[] args)
    {
        System.Timers.Timer aTimer = new System.Timers.Timer();
        aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
        // Set the Interval to 5 seconds.
        aTimer.Interval = 5000;
        aTimer.Enabled = true;

        Thread worker = new Thread(new ThreadStart(ThreadMethod2));
        worker.Start();

        Console.WriteLine("Press \'q\' to quit the sample.");
        while (Console.Read() != 'q') ;

        stop = true;
        worker.Join();

        return;
    }
}

namespace Template
{
    public partial class Template
    {
        private System.Timers.Timer tt = null ;
 
        public Template
        (
            int Interval
        )
        {
            tt = new System.Timers.Timer ( Interval ) ;
 
            tt.Elapsed += F ;
 
            return ;
        }
 
        private void
        F
        (
            object                         sender
        ,
            System.Timers.ElapsedEventArgs e
        )
        {
            System.Console.WriteLine ( System.DateTime.Now.ToString() ) ;
 
            // Do other stuff
 
            return ;
        }
 
        public void
        Start
        (
        )
        {
            tt.Start() ;
 
            return ;
        }
 
        public void
        Stop
        (
        )
        {
            tt.Stop() ;
 
            return ;
        }
 
        [System.STAThreadAttribute()]
        public static int
        Main
        (
            string[] args
        )
        {
            int result = 0 ;
 
            try
            {
                Template x = new Template ( 5000 ) ;
 
                x.Start() ;
 
                System.Console.ReadLine() ;
 
                x.Stop() ;
            }
            catch ( System.Exception err )
            {
                while ( err != null )
                {
                    System.Console.WriteLine ( err.Message ) ;
 
                    err = err.InnerException ;
                }
            }
 
            return ( result ) ;
        }
    }
}