Breaking News: Grepper is joining You.com. Read the official announcement!

What is an important point to consider while passing an object from one thread to another thread?

Add Answer

Pragya Keshap answered on February 4, 2023 Popularity 1/10 Helpfulness 1/10

answer What is an important point to consider while passing an object from one thread to another thread?

What is an important point to consider while passing an object from one thread to another thread?

Comment

This is a multi-threading scenario. In a multi-threading scenario, the

most important point is to check whether two threads can update

same object at the same time.

If it is possible for two threads to update the same object at the

same time, it can cause issues like race condition.

So it is recommended to make the object Immutable. This will help

in avoiding any concurrency issues on this object

public class ThreadWithState
{
    // State information used in the task.
    private string boilerplate;
    private int numberValue;

    // Delegate used to execute the callback method when the
    // task is complete.
    private ExampleCallback callback;

    // The constructor obtains the state information and the
    // callback delegate.
    public ThreadWithState(string text, int number,
        ExampleCallback callbackDelegate)
    {
        boilerplate = text;
        numberValue = number;
        callback = callbackDelegate;
    }

    // The thread procedure performs the task, such as
    // formatting and printing a document, and then invokes
    // the callback delegate with the number of lines printed.
    public void ThreadProc()
    {
        Console.WriteLine(boilerplate, numberValue);
        if (callback != null)
            callback(1);
    }
}

// Delegate that defines the signature for the callback method.
//
public delegate void ExampleCallback(int lineCount);

// Entry point for the example.
//
public class Example
{
    public static void Main()
    {
        // Supply the state information required by the task.
        ThreadWithState tws = new ThreadWithState(
            "This report displays the number {0}.",
            42,
            new ExampleCallback(ResultCallback)
        );

        Thread t = new Thread(new ThreadStart(tws.ThreadProc));
        t.Start();
        Console.WriteLine("Main thread does some work, then waits.");
        t.Join();
        Console.WriteLine(
            "Independent task has completed; main thread ends.");
    }

    // The callback method must match the signature of the
    // callback delegate.
    //
    public static void ResultCallback(int lineCount)
    {
        Console.WriteLine(
            "Independent task printed {0} lines.", lineCount);
    }
}

https://learn.microsoft.com/en-us/dotnet/standard/threading/creating-threads-and-passing-data-at-start-time

Popularity 1/10 Helpfulness 1/10 Language csharp

Source: Grepper

Tags: c# object point

Link to this answer
Share Copy Link

Contributed on Feb 04 2023

Pragya Keshap

0 Answers Avg Quality 2/10

What is an important point to consider while passing an object from one thread to another thread?

Contents

More Related Answers

What is an important point to consider while passing an object from one thread to another thread?

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.