多线程和委托

原创已于 2023-03-21 16:18:44 修改 · 860 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#C#

于 2017-04-08 08:18:39 首次发布

//Task 取消线程

        CancellationTokenSource cts = new CancellationTokenSource();

            cts.Cancel();//传达取消请求

            if (cts.IsCancellationRequested)
            {
                MessageBox.Show(@"取消成功.");
            }
            else
            {
                MessageBox.Show(@"没有取消,还在执行.");
            }
            Task.Factory.StartNew(new Action(() =>
            {
                MessageBox .Show (@"这里是一个委托.");
            }),cts .Token );//cts .Token就是记录会在cath在把已取消的线程显示

//这种不会卡界面

      var result = await Task.WhenAll(boolTaskList);//异步
      Task<bool> task1 = Task<bool>.Run(() => { return falsh.Test(); });
      await task1;//异步

Task Fun带返回值的方法使用

List<Task<string >> task = new List<Task<string >>();
foreach (string[,] t in snMac)
{
task.Add ( Task<string>.Factory.StartNew(() => Test(t, folderAll)));
}
await Task.WaitAll(task.ToArray());
foreach (var itmes in task)
{
txt_out.AppendText(itmes.Result);//取值
}

另一种多线程跨线程

            TaskScheduler scheduler = TaskScheduler.FromCurrentSynchronizationContext();
            new TaskFactory().StartNew(() =>
            {
                chart1.Series["val"].Points.DataBindXY(timeDate, xarray);
 
                chart1.Series["wd"].Points.DataBindXY(timeDate, xarray2);
                label1.Text = @"现在真是要学习";
            }, CancellationToken.None, TaskCreationOptions.None, scheduler);//感觉这种很方便

多线程同步锁：（独占对象）

lock();//只能锁定引用不能锁定值类型,比如可以锁list,数组,静态变量.objet、this.,锁住同一个对象(引用地址)就会互斥.

锁定时要考虑到底要锁什么对象,是为了锁定内容在使用时不被其它多线程修改.

为什么锁不了值型？

如果你传一个值类型，会装箱，下次代码运行到这里，又会装箱，两次不是同一个对象，所以锁不住.

异步委托

Func<string, string, int> length = (aa, bb) => aa.Length + bb.Length; //声明一个有参数和有返回值的委托
IAsyncResult cc = length.BeginInvoke("654646", "654654+45", null, null);//异步调用

while (!cc.IsCompleted) { out.text="还没有完成,等待中"};//如果cc.IsCompleted==true那就是执行完了,可以放在特殊的地方确认状态
int dd = length.EndInvoke(cc);//等待调用的结果,这里会阻塞主线程，一直在这里等着

带回调的异步委托

｛

button1.Enabled = false;
Func<string, string, int> length = ((aa, bb) =>
{
Thread.Sleep(2000);
return aa.Length + bb.Length;
});
length.BeginInvoke("654646", "654654+45", Deletgate_Next, length);

MessageBox.Show("这里是主线程");

public void Deletgate_Next(IAsyncResult o)//回调函数，传回来的是length
{
var del = (Func<string, string, int>) o.AsyncState;//将o接口对象转为对应的实例对象
int value = del.EndInvoke(o); //等待结果
MessageBox.Show(value.ToString());
if (button1.InvokeRequired)
{ button1.Invoke(new Action(() => { button1.Enabled = true; })); }
}

｝//这里的执行流程会是,先调用异步线程,然后主线程继续执行,然后在回调函数里执行异步委托的结果

//下面是使用Action委托

private void button2_Click(object sender, EventArgs e)
{
string srt = "";
Action<string, string> length = ((aa, bb) =>
{
Thread.Sleep(2000);
srt = aa + bb;
});
length.BeginInvoke("546545", "65465w", MyAsyncCallback, length);
MessageBox.Show("主函数");
}

public void MyAsyncCallback(IAsyncResult result)
{
Action<string, string> del = (Action<string, string>)result.AsyncState;
del.EndInvoke(result);
MessageBox.Show("异步回调函数");
}