C#多线程
一多线程的几种方式
统一用于测试的模拟下载代码
private static void DownMethod(int id,string fileName)
{
Console.WriteLine("开始下载！文件ID：{0}，文件名字{1}", id, fileName);
for (int i = 0; i < 100; i+=10)
{
Thread.Sleep(10);
Console.WriteLine("已经下载{0}", i);
}
Console.WriteLine("下载完毕！！！");
}
1：委托创建线程实现异步
实例1：Action委托创建线程
//多线程的第一种方式Action委托没有返回值
public static void ThreadMethod(int id, string fileName)
{
DownMethod(id,fileName);
}
static void Main(string[] args)
{
//方法一：使用Action委托来异步执行方法
Action<int, string> fileDownAction = ThreadMethod;
//前面的参数是委托所需要的参数，后面两个是固定的，一个是线程结束回调，一个是传入回调的参数
fileDownAction.BeginInvoke(1, "天才在左疯子在右", ar =>
{
Console.WriteLine("线程结束回调");
Console.WriteLine(ar.AsyncState as string);//最后一个参数
fileDownAction.EndInvoke(ar);//这个方法用于获取此线程的返回值，由于Action委托没有返回值，所以不返回
}, "回调的参数");
Console.WriteLine("我是主线程");
Console.ReadKey();
}
结果
我是主线程
开始下载！文件ID：1，文件名字天才在左疯子在右
已经下载0
已经下载10
已经下载20
已经下载30
已经下载40
已经下载50
已经下载60
已经下载70
已经下载80
已经下载90
下载完毕！！！
线程结束回调
回调的参数
实例2：Func委托创建线程
public static string FuncThreadMethod(int id, string fileName)
{
DownMethod(id, fileName);
return "异步方法的返回值！！！";
}
static void Main(string[] args)
{
Func<int, string,string> fileDownAction = FuncThreadMethod;
//前面的参数是委托所需要的参数，后面两个是固定的，一个是线程结束回调，一个是传入回调的参数
fileDownAction.BeginInvoke(1, "天才在左疯子在右", ar =>
{
Console.WriteLine("线程结束回调");
Console.WriteLine(ar.AsyncState as string);//最后一个参数
string result = fileDownAction.EndInvoke(ar);//这个方法用于获取此线程的返回值，由于Action委托没有返回值，所以不返回
Console.WriteLine(result);
}, "回调的参数");
Console.WriteLine("我是主线程");
Console.ReadKey();
}
}
我是主线程
开始下载！文件ID：1，文件名字天才在左疯子在右
已经下载0
已经下载10
已经下载20
已经下载30
已经下载40
已经下载50
已经下载60
已经下载70
已经下载80
已经下载90
下载完毕！！！
线程结束回调
回调的参数
异步方法的返回值！！！
2：Thread创建异步线程
实例1：普通的方式
//使用Thread方式创建的委托方法一定没有返回值，参数可有可无，但是有参数的话一定是object类型的
public static void AsyncWithThreadMethod(object obj)
{
Console.WriteLine("开始下载！文件名字{0}", obj as string);
for (int i = 0; i < 100; i += 10)
{
Thread.Sleep(10);
Console.WriteLine("已经下载{0}", i);
}
Console.WriteLine("下载完毕！！！");
}
static void Main(string[] args)
{
//Thread创建线程的方式，Thread的构造参数一定是个无返回值的委托
Thread thread = new Thread(AsyncWithThreadMethod);
thread.Start("天才在左疯子在右");
Console.WriteLine("我是主线程");
Console.ReadKey();
}
lambda表达式方式：
Thread thread = new Thread((obj) =>
{
Console.WriteLine("开始下载！文件名字{0}", obj as string);
for (var i = 0; i < 100; i += 10)
{
Thread.Sleep(10);
Console.WriteLine("已经下载{0}", i);
}
Console.WriteLine("下载完毕！！！");
});
thread.Start("天才在左疯子在右");
但是这种方式如果想要传递一些复杂的或者多个参数就不好弄了，所以可以用另一种方式，自己新建一个类来处理
class MyThread
{
private int id;
private string name;
public MyThread(int id, string name)
{
this.id = id;
this.name = name;
}
private void DownFileStart(object callback)
{
Action<string> action = callback as Action<string>;
Console.WriteLine("开始下载！文件ID：{0}，文件名字{1}", id, name);
for (int i = 0; i < 100; i += 10)
{
Thread.Sleep(10);
Console.WriteLine("已经下载{0}", i);
}
Console.WriteLine("下载完毕！！！");
action?.Invoke("下载完毕！！！！");
}
//这个方法使用回调来处理线程执行完毕的结果
public void Start(Action<string> callback)
{
Thread t = new Thread(DownFileStart);
t.Start(callback);
}
}
使用：
MyThread mt = new MyThread(1, "aaa");
mt.Start(o =>
{
Console.WriteLine("线程完成回调---->{0}", o);
});
Console.WriteLine("我是主线程");
Console.ReadKey();
结果：
我是主线程
开始下载！文件ID：1，文件名字天才在左疯子在右
已经下载0
已经下载10
已经下载20
已经下载30
已经下载40
已经下载50
已经下载60
已经下载70
已经下载80
已经下载90
下载完毕！！！
线程完成回调---->下载完毕！！！！
前台线程和后台线程
前台线程：Thread创建的线程默认都是前台线程，前台线程不会跟随主线程的停止而停止，如果主线程提前停止，程序会跟着前台线程的停止而停止
后台线程：使用线程池创建的线程都是后台线程，不会被更改，主线程停止了后台线程也就随之停止了，Thread可以设置IsBackground = true;来设置为后台线程
3：线程池创建线程
线程池类ThreadPool是静态类，无法被声明和new，只能通过类名来调用里面的静态方法
一般通过线程池创建线程的方法如下:
ThreadPool.QueueUserWorkItem(state =>
{
Console.WriteLine("创建线程池的线程，参数：{0}，线程ID：{1}", state as string, Thread.CurrentThread.ManagedThreadId);
}, "11");
一般来说线程池用于处理多个耗时较为少的任务，不推荐处理长时间任务
4：任务（Task）
(模拟线程代码)
private static void DownMethod(int id, string fileName)
{
Console.WriteLine("开始下载！文件ID：{0}，文件名字{1}", id, fileName);
for (int i = 0; i < 100; i += 10)
{
Thread.Sleep(10);
Console.WriteLine("已经下载{0}", i);
}
Console.WriteLine("下载完毕！！！");
}
//多线程的第一种方式Action委托没有返回值
public static string ThreadMethod()
{
DownMethod(1, "天才在左疯子在右");
return "1111";
}
public static void SaveInFile(Task task)
{
Console.WriteLine("正在存储文件");
Thread.Sleep(1000);
Console.WriteLine("存储完毕！！！");
}
任务有两种创建方式
- 泛型代表返回值
Task<string> t = new Task<string>(ThreadMethod);
t.Start();
TaskFactory<string> tf = new TaskFactory<string>();
tf.StartNew(ThreadMethod);
连续任务
当任务1依赖于任务2的时候那就需要任务2执行完毕之后执行任务1，这个时候用连续任务
TaskFactory<string> tf = new TaskFactory<string>();
var startNew = tf.StartNew(ThreadMethod);
//主要是这句话
var startNew2 = startNew.ContinueWith(SaveInFile);
任务的层次结构
如果在一个任务中再次调用一个任务，那么内部这个任务就是外边的任务的子任务，如果子任务没有执行完毕而父任务执行完毕的话，则父任务的状态是WaitingForChildrenToComplete,只有子任务执行完了，父任务的状态就变成了RunToComplete
4：线程争用问题（同步锁）
测试类：
/// <summary>
/// 测试线程争用问题
/// </summary>
class MyThreadObject
{
//用于测试多线程争用同一变量的变量
private int state = 5;
public void ChangeState()
{
state++;
if (state == 5)
{
Console.WriteLine("state =5");//正常来讲是永远不会执行这一句的
}
state = 5;//当其中一个线程执行到这一句的时候另一个线程刚执行到if (state == 5)，这时就会打印
}
}
主函数：
class Program
{
static void ChangeMyThreadState(object obj)
{
var myThread = obj as MyThreadObject;
while (true)
{
myThread?.ChangeState();
}
}
private static void Main(string[] args)
{
MyThreadObject myThread = new MyThreadObject();
Thread t1 = new Thread(ChangeMyThreadState);
t1.Start(myThread); //只有这一个线程是没有问题的
Thread t2 = new Thread(ChangeMyThreadState);
t2.Start(myThread); //加上这个线程就会出问题，
Console.WriteLine("我是主线程");
Console.ReadKey();
}
}
结果是打印了好多。
解决方法是加同步锁
static void ChangeMyThreadState(object obj)
{
var myThread = obj as MyThreadObject;
while (true)
{
if (myThread == null) continue;
lock (myThread) //像系统申请锁定需要调用的对象，如果另一个线程执行到这发现被锁定了则会等待锁定结束，然后继续执行
{
myThread.ChangeState(); //在同一时刻只有一个线程执行
}
}
}
注意：lock只能锁定对象（引用类型）
4：线程死锁
class Program
{
static MyThreadObject myThread = new MyThreadObject();
static MyThreadObject myThread1 = new MyThreadObject();
static void ChangeMyThreadState(object obj)
{
while (true)
{
lock (myThread) //像系统申请锁定需要调用的对象，如果另一个线程执行到这发现被锁定了则会等待锁定结束，然后继续执行
{
lock (myThread1)
{
myThread.ChangeState(); //在同一时刻只有一个线程执行
Console.WriteLine("0000");
}
}
}
}
static void ChangeMyThreadState1(object obj)
{
while (true)
{
lock (myThread1) //像系统申请锁定需要调用的对象，如果另一个线程执行到这发现被锁定了则会等待锁定结束，然后继续执行
{
lock (myThread)
{
myThread.ChangeState(); //在同一时刻只有一个线程执行
Console.WriteLine("11111");
}
}
}
}
private static void Main(string[] args)
{
Thread t1 = new Thread(ChangeMyThreadState);
t1.Start(); //只有这一个线程是没有问题的
Thread t2 = new Thread(ChangeMyThreadState1);
t2.Start(); //加上这个线程就会出问题，
Console.WriteLine("我是主线程");
Console.ReadKey();
}
}
执行结果只打印了10几条，就停止了
