C#

csc /out:My.exe *.cs

Bastard Programmer from Hell

csc MyFirstClass.cs MySecondClass.cs etc.cs

Thread T1 = new Thread(new ParameterizedThreadStart(Y));
T1.Start(42);
...
public static void Y(object i) { Console.WriteLine("Hello: "+ i); }

public static void Y(double a, DateTime[] myDates, Dictionary<string,double> myDic)

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading;



namespace mtquestion

{

    class Program

    {

       

        static void Main(string[] args)

        {



           

            Thread T1 = new Thread(new ParameterizedThreadStart(C));

            Thread T2 = new Thread(new ParameterizedThreadStart(C));

            Thread T3 = new Thread(new ParameterizedThreadStart(C));

         



            

            T1.Start(15000000);

            T2.Start(25000000);

            T3.Start(60000);



           

            T1.Join();

            T2.Join();

            T3.Join();

        

            Console.WriteLine("All 3 done");



        }



        //dummy function to spend time

        public static void C(object i) 

        {

            

           double y = 0.0;

            for (int j = 1; j<(int) i; j++)

            {

                y += Math.Log(Math.Exp(0.06)) * Math.Log(Math.Exp(0.06)) / Math.Log(Math.Exp(0.06)) * Math.Log(Math.Exp(0.06)); 

            }

            

            Console.WriteLine(i);

        }

        public static void Total(object j) 

        {

        //..... sum y of each
 C(..) when conclueded
        }

			

    }

}

class Job {
    private int parm1;
    private int parm2;
    public int Result;
    private Thread thread;

    public Job(int parm1, int parm2) {
        this.parm1=parm1;
        this.parm2=parm2;
    }

    public void Run() {
        thread=new Thread(new ThreadStart(runner));
        thread.Start();
    }

    public void Join() {
        thread.Join();
    }

    private void runner() {
        Result=parm1+parm2;
    }
}

class Test {
    public static Main() {
        List<Job> jobs=new List<Job>();
        for(int i=0; i<10; i++) {
            Job job=new Job(3*i, i+12);
            jobs.Add(job);
            job.Run();
        }
        foreach(Job job in jobs) job.Join();
        int total=0;
        foreach(Job job in jobs) total+=job.Result;
    }
}

Luc Pattyn wrote:

Atomic here means the data operation is performed by a single assembler instruction,

add dword ptr[esp+0x20], eax
inc dword ptr[edi]
; other r-m-w instructions

Luc Pattyn wrote:

so if two ints need to represent a consistent state, then you also would need a lock

class MyTask {
 double a,b;
 Thread t;
 ManualResetEvent wh;

 ManualResetEvent WaitHandle { get { return wh; } }
 public Thread Thread { get { return t; } }

 MyTask(double a, double b) {
  this.a = a; this.b = b; 
  t = new Thread(new ThreadStart(Run));
  wh = new ManualResetEvent();
 }

 private void Run(){
  // do whatever with a and b
  wh.Signal();
 }
}

Thread thread = new MyTask(11, 15).Thread;
thread.Start();

MyTask task = new MyTask(11, 15);
task.Thread.Start();
task.WaitHandle.WaitOne();

if (dt.Rows[0][colname] != DBNull.Value) ...

PIEBALDconsult wrote:

Don't ever use the Convert class

PIEBALDconsult wrote:

Because it's needless, nearly all its methods simply wrap other methods (e.g. Int32.Parse). It offers no benefit and adds an extra method call.

PIEBALDconsult wrote:

It's more a matter of style, discipline, and clarity of thought.

PIEBALDconsult wrote:

All of which do matter if you want to produce a quality product.