Resource sharing about C# video tutorials

"C# Tutorial" is an introductory course for the C# language. In the course, it will start from the basic concepts of the .NET platform and C#, and provide an in-depth introduction to the basic syntax of C# development, simple program logic, and the use of Visual Studio tools. Implementation of commonly used algorithms. At the same time, we also hope that through course-related exercises and programming exercises, we can help students quickly get into the C# language.

Course playback address: http://www.php.cn/course/84.html

The teacher’s teaching style:

The teacher’s lectures are simple, clear, layer-by-layer analysis, interlocking, rigorous argumentation, rigorous structure, and use the logical power of thinking to attract students’ attention Strength, use reason to control the classroom teaching process. By listening to the teacher's lectures, students not only learn knowledge, but also receive thinking training, and are also influenced and influenced by the teacher's rigorous academic attitude

The more difficult point in this video is C# multi-threading:

1. Reasons for using threads

1. Threads can be used to isolate code from other codes and improve the reliability of applications. .

2. Threads can be used to simplify coding.

3. Threads can be used to achieve concurrent execution.

2. Basic knowledge

1. Process and thread: As the basic unit of operating system execution program, process has the resources of application program. Process contains threads. The resources of process are shared by threads. Threads Does not own resources.

2. Foreground thread and background thread: New threads created through the Thread class default to the foreground thread. When all foreground threads are closed, all background threads will also be terminated directly without throwing an exception.

3. Suspend (Suspend) and wake-up (Resume): Since the execution order of threads and the execution of the program are unpredictable, using suspend and wake-up is prone to deadlock. In practical applications, it should be Use as little as possible.

4. Blocking thread: Join, blocking the calling thread until the thread terminates.

5. Terminate the thread: Abort: Throw a ThreadAbortException exception to terminate the thread. The terminated thread cannot be awakened. Interrupt: Throws a ThreadInterruptException exception to terminate the thread, and execution can continue by catching the exception.

6. Thread priority: AboveNormal BelowNormal Highest Lowest Normal, the default is Normal.

3. The use of threads

Thread functions are passed through delegation. They can be passed without parameters or with parameters (there can only be one parameter). The parameters can be encapsulated in a class or structure.

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(new ThreadStart(TestMethod));
            Thread t2 = new Thread(new ParameterizedThreadStart(TestMethod));
            t1.IsBackground = true;
            t2.IsBackground = true;
            t1.Start();
            t2.Start("hello");
            Console.ReadKey();
        }

        public static void TestMethod()
        {
            Console.WriteLine("不带参数的线程函数");
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine("带参数的线程函数，参数为：{0}", datastr);
        }
    } 
}

4. Thread pool

Since the creation and destruction of threads requires a certain amount of overhead, excessive use of threads will cause memory resources Due to the waste of performance, the concept of thread pool was introduced. The thread pool maintains a request queue. The thread pool code extracts the task from the queue and then delegates it to a thread in the thread pool for execution. The thread will not be destroyed immediately after execution, so that tasks can be executed in the background and thread creation and destruction can be reduced. the expenses incurred.

The thread pool thread defaults to the background thread (IsBackground).

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            //将工作项加入到线程池队列中，这里可以传递一个线程参数
            ThreadPool.QueueUserWorkItem(TestMethod, "Hello");
            Console.ReadKey();
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine(datastr);
        }
    }
}

5. Task class

It is very simple to use the QueueUserWorkItem() method of ThreadPool to initiate an asynchronous thread execution, but the The biggest problem with methods is that there is no built-in mechanism to let you know when the operation is completed, and whether there is a built-in mechanism to obtain a return value after the operation is completed. For this purpose, you can use the Task class from System.Threading.Tasks.

Construct a Task object and pass the return type of an operation for the generic TResult parameter.

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
            t.Start();
            t.Wait();
            Console.WriteLine(t.Result);
            Console.ReadKey();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; --n)
                checked{ sum += n;} //结果太大，抛出异常
            return sum;
        }
    }
}

When a task is completed, a new task is automatically started.
After a task is completed, it can start another task. The previous code is rewritten below without blocking any threads.

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
            t.Start();
            //t.Wait();
            Task cwt = t.ContinueWith(task => Console.WriteLine("The result is {0}",t.Result));
            Console.ReadKey();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; --n)
                checked{ sum += n;} //结果溢出，抛出异常
            return sum;
        }
    }
}

6. Asynchronous execution of delegates

Asynchronous calls of delegates: BeginInvoke() and EndInvoke()

namespace Test
{
    public delegate string MyDelegate(object data);
    class Program
    {
        static void Main(string[] args)
        {
            MyDelegate mydelegate = new MyDelegate(TestMethod);
            IAsyncResult result = mydelegate.BeginInvoke("Thread Param", TestCallback, "Callback Param");

            //异步执行完成
            string resultstr = mydelegate.EndInvoke(result);
        }

        //线程函数
        public static string TestMethod(object data)
        {
            string datastr = data as string;
            return datastr;
        }

        //异步回调函数
        public static void TestCallback(IAsyncResult data)
        {
            Console.WriteLine(data.AsyncState);
        }
    }
}

7. Thread synchronization

　1) Atomic Operation (Interlocked): All methods perform an atomic read or write operation.

　2) lock() statement: Avoid locking public types, otherwise the instance will exceed the scope of code control. Define private objects to lock.

3) Monitor implements thread synchronization

The acquisition and release of exclusive locks are achieved through Monitor.Enter() and Monitor.Exit(). After acquisition, the resources are exclusive and no other threads are allowed to access.

There is also a TryEnter method, which will not block and wait when the resource cannot be requested. You can set a timeout and return false if it cannot be obtained.

　4) ReaderWriterLock

　 When the resource operation involves more reading and less writing, in order to improve resource utilization, the read operation lock is a shared lock, so that multiple threads can read the resource concurrently. The write operation is an exclusive lock and only one thread is allowed to operate.

　5) Event class implements synchronization

The event class has two states, the terminated state and the non-terminated state. Calling WaitOne in the terminated state can request success, and set the time status to the terminated state through Set.

1) AutoResetEvent (automatic reset event)

2) ManualResetEvent (manual reset event)

6) Semaphore

Signal The quantity is an int variable maintained by the kernel object. When it is 0, the thread is blocked. When it is greater than 0, it is unblocked. When the waiting thread on a semaphore is unblocked, the semaphore count is +1.

The thread decreases the semaphore by 1 through WaitOne and increases the semaphore by 1 through Release. It is very simple to use.

7) Mutex (Mutex)

Exclusive resources, usage is similar to Semaphore.

8) Cross-process synchronization

System-level synchronization can be achieved by setting the name of the synchronization object. Different applications identify different synchronization objects through the name of the synchronization object.

The above is the detailed content of Resource sharing about C# video tutorials. For more information, please follow other related articles on the PHP Chinese website!