Best way to define, start and stop threads in C#

I am making a little program, which have few Threads, constantly running.
At some point, I may want to stop one of them, and then, after random period of time, to start it again.
So first, what is the best way to define a Thread, here’s my code

private void startCheckCommandThread() {
        isRunning = true;
        //commandThread = new Thread(checkForCommand);
        //commandThread.IsBackground = true;
        //commandThread.Start();

        new Thread(() => {
            Thread.CurrentThread.IsBackground = true;
            checkForCommand();
        }).Start();
    }

The commented way, or the other one?
And here is how I am stopping and restarting them:

// get condition variable
if (condition) {
    isRunning = false;
    // here it must be 100% guaranteed that the Thread will stop
} else {
    startCheckCommandThread();
}

So what is the best way to do it, mostly I am asking about stability (meaning error-proof) and maximum performance (as low CPU usage as possible, and as less memory allocation as possible)?

I am making a little program, which have few Threads, constantly running. At some point, I may want to stop one of them, and then, after random period of time, to start it again. What is the best way to create a thread?

The best way is to not do it at all. If I have work that needs to be done in parallel to another program, the best practice is to start another process. If I have work that needs to be done asynchronously then I use the Task Parallel Library and let it manage my threads.

Threads are simply the wrong unit of granularity for most tasks. Threads are workers; rather than managing workers, instead manage tasks; let the TPL figure out how many workers are necessary.

mostly I am asking about stability (meaning error-proof)

Threading code is notoriously difficult to get right. You have to worry about coherency, memory barriers, non-atomic reads and writes, deadlocks, livelocks, … That’s why using processes is far better.

If you have to keep everything in one process then use the highest level tool available. Again, do not attempt to manipulate threads directly. If you have asynchronous work to do, use the TPL. If you need to cancel some of that work, use cancellation tokens. Do not attempt to control threads directly; you will get it wrong.

If for some reason you don’t want to use the TPL and you do want to use threads directly, then build a scheme whereby the threads communicate over well-defined, carefully-tested channels and have the code reviewed by experts. You don’t ever want to abort a thread except under emergency conditions; doing so can corrupt your data structures in unusual ways. If you need a thread to shut down then you want to have a carefully designed and carefully implemented system that allows one thread to clearly signal another thread that it is time to shut down, and have that thread shut down cleanly.

and maximum performance (as low CPU usage as possible, and as less memory allocation as possible)?

I never understand why people say “I want to use threads to keep my CPU utilization low”. Threads are there to keep your CPU utilization high. You paid good money for those CPUs; use them! The ideal situation is to have all the CPUs in your machine going at 100% all the time doing useful work. You wouldn’t say that your goal was to build a factory where the workers were idle 95% of the time, so why would you do the same for a program?

Threads keep your CPU utilization high because if you’re smart about it, you’ll assign one thread of CPU-bound work to each CPU, and have that CPU do nothing else other than work on the problem you throw at it. If you have more CPU-bound work than CPUs, and more threads to handle it, then the CPUs are going to be switching back and forth between threads and everything gets less efficient.

If you want to avoid memory allocation, by all means keep your thread count as low as possible. Threads are about the most memory-expensive resource you can possibly allocate. Each one by default consumes a million bytes of address space for the stack.

With regards to the two ways of starting the thread, they are roughly equivalent, so it is a matter of whether you prefer a lambda.

For stopping the thread, the most error proof way is to check a field value for a change. This can be done using a memory barrier, for example, using a lock statement or a Monitor will automatically provide a memory barrier. The simplest way to synchronize the threads is to use a lock statement around all access and modification of a boolean field. The field would be contained in an object associated with the thread to be stopped.

When the variable changes, you exit the thread by returning from the top-level method that is executing in the thread.

Most developers do not “reuse” a thread. Once you exit it, it is gone — you have to create a new one. You can reuse the object associated with the thread. While you could hold onto the thread, suspending it until you need it, generally this is considered poor design, as the thread is wasting resources while it is suspended. Also, it must block in such a way that it does not burn cycles while waiting.

If you are interested in maximum performance, you will may wish to look at synchronization using Interlocked. This is faster, but hard to use. Don’t use it if you are just starting with multithreading. I recommend this web site for threading tutorials:
Threading in C#

The best way to manage threads is to not do it.

Use of threading is not an objective, it is a means to an end, viz. concurrency. In C# we achieve concurrency without direct thread management by virtue of async/await, or sometimes (as mentioned by others) lambda expressions, most commonly via PLINQ.

It is expensive, slow and subject to availability to start and stop threads. Instead, the above approaches use a pool of preallocated threads. The resources are marshalled at set up and tear down of the process by code written by people with significant thread management experience.

They also have access to the platform developers, and full scale test teams who also have appropriate experience. It is unlikely that any application development team can match that.

Filed under: softwareengineering - @ 17:04

Thẻ: .net, c++, multithreading

Best way to define, start and stop threads in C#

private void startCheckCommandThread() {
        isRunning = true;
        //commandThread = new Thread(checkForCommand);
        //commandThread.IsBackground = true;
        //commandThread.Start();

        new Thread(() => {
            Thread.CurrentThread.IsBackground = true;
            checkForCommand();
        }).Start();
    }

The commented way, or the other one?
And here is how I am stopping and restarting them:

// get condition variable
if (condition) {
    isRunning = false;
    // here it must be 100% guaranteed that the Thread will stop
} else {
    startCheckCommandThread();
}

So what is the best way to do it, mostly I am asking about stability (meaning error-proof) and maximum performance (as low CPU usage as possible, and as less memory allocation as possible)?

I am making a little program, which have few Threads, constantly running. At some point, I may want to stop one of them, and then, after random period of time, to start it again. What is the best way to create a thread?

Threads are simply the wrong unit of granularity for most tasks. Threads are workers; rather than managing workers, instead manage tasks; let the TPL figure out how many workers are necessary.

mostly I am asking about stability (meaning error-proof)

and maximum performance (as low CPU usage as possible, and as less memory allocation as possible)?

With regards to the two ways of starting the thread, they are roughly equivalent, so it is a matter of whether you prefer a lambda.

When the variable changes, you exit the thread by returning from the top-level method that is executing in the thread.

The best way to manage threads is to not do it.

They also have access to the platform developers, and full scale test teams who also have appropriate experience. It is unlikely that any application development team can match that.

Filed under: softwareengineering - @ 17:04

Thẻ: .net, c++, multithreading

Best way to define, start and stop threads in C#

private void startCheckCommandThread() {
        isRunning = true;
        //commandThread = new Thread(checkForCommand);
        //commandThread.IsBackground = true;
        //commandThread.Start();

        new Thread(() => {
            Thread.CurrentThread.IsBackground = true;
            checkForCommand();
        }).Start();
    }

The commented way, or the other one?
And here is how I am stopping and restarting them:

// get condition variable
if (condition) {
    isRunning = false;
    // here it must be 100% guaranteed that the Thread will stop
} else {
    startCheckCommandThread();
}

So what is the best way to do it, mostly I am asking about stability (meaning error-proof) and maximum performance (as low CPU usage as possible, and as less memory allocation as possible)?

I am making a little program, which have few Threads, constantly running. At some point, I may want to stop one of them, and then, after random period of time, to start it again. What is the best way to create a thread?

Threads are simply the wrong unit of granularity for most tasks. Threads are workers; rather than managing workers, instead manage tasks; let the TPL figure out how many workers are necessary.

mostly I am asking about stability (meaning error-proof)

and maximum performance (as low CPU usage as possible, and as less memory allocation as possible)?

With regards to the two ways of starting the thread, they are roughly equivalent, so it is a matter of whether you prefer a lambda.

When the variable changes, you exit the thread by returning from the top-level method that is executing in the thread.

The best way to manage threads is to not do it.

They also have access to the platform developers, and full scale test teams who also have appropriate experience. It is unlikely that any application development team can match that.

Filed under: softwareengineering - @ 17:04

Thẻ: .net, c++, multithreading

Thiết kế website giá rẻ

Danh mục

Best way to define, start and stop threads in C#

Best way to define, start and stop threads in C#

Best way to define, start and stop threads in C#