ThreadPool 是 .net 2.0 时代的产物,有了 Thread 为什么还会有 ThreadPool 呢?ThreadPool 可以做到限制线程数量、重用线程
启动线程池线程
ThreadPool 提供的 API 相对于 Thread 是比较少的,在 ThreadPool 中需使用 QueueUserWorkItem 方法,来启动一个线程
例如:Dosome 是个普通的方法,传入 QueueUserWorkItem 方法开启新线程执行此方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public static void Dosome()
{
Console.WriteLine($ "Task Start ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
}
static void Main( string [] args)
{
Console.WriteLine($ "Main 方法开始,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
ThreadPool.QueueUserWorkItem(x => Dosome());
Console.WriteLine($ "Main 方法结束,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Console.ReadLine();
}
|
启动线程,可以看到新开启了一个子线程 3 执行任务,而主线程 1 并没有等待子线程 3
线程池线程数量
在 1.0 时代的 Thread 是没有线程数量概念的,在 ThreadPool 2.0 时代,线程池线程数量可以通过 SetMaxThreads、SetMaxThreads 方法设置最小最大线程。也可以查看线程池线程数量,以通过 GetMinThreads、GetMaxThreads 方法获取线程池最小及最大线程数量。
注意:一般不建议设置 ThreadPool 线程数量,这个操作是全局的。二般情况,当线程池线程耗尽,会造成死锁。
例如:以通过 SetMaxThreads、SetMaxThreads、GetMinThreads、GetMaxThreads 方法来操作查看线程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
{
ThreadPool.GetMinThreads( out int workerThreadsMin, out int completionPortThreadsMin); //工作线程,io线程
Console.WriteLine($ "【default】最小 workerThreadsMin:{workerThreadsMin} completionPortThreadsMin:{completionPortThreadsMin}" );
ThreadPool.GetMaxThreads( out int workerThreadsMax, out int completionPortThreadsMax); //工作线程,io线程
Console.WriteLine($ "【default】最大 workerThreadsMax:{workerThreadsMax} completionPortThreadsMax:{completionPortThreadsMax}" );
}
ThreadPool.SetMinThreads(3, 3); // 设置4其实也不是4,应为本机为逻辑八核,最小也就是这个
ThreadPool.SetMaxThreads(7, 7);
{
ThreadPool.GetMinThreads( out int workerThreadsMin, out int completionPortThreadsMin); //工作线程,io线程
Console.WriteLine($ "【自定义】最小 workerThreadsMin:{workerThreadsMin} completionPortThreadsMin:{completionPortThreadsMin}" );
ThreadPool.GetMaxThreads( out int workerThreadsMax, out int completionPortThreadsMax); //工作线程,io线程
Console.WriteLine($ "【自定义】最大 workerThreadsMax:{workerThreadsMax} completionPortThreadsMax:{completionPortThreadsMax}" );
}
ThreadPool.SetMinThreads(5, 5); // 设置4其实也不是4,应为本机为逻辑八核,最小也就是这个
ThreadPool.SetMaxThreads(16, 16);
{
ThreadPool.GetMinThreads( out int workerThreadsMin, out int completionPortThreadsMin); //工作线程,io线程
Console.WriteLine($ "【自定义】最小 workerThreadsMin:{workerThreadsMin} completionPortThreadsMin:{completionPortThreadsMin}" );
ThreadPool.GetMaxThreads( out int workerThreadsMax, out int completionPortThreadsMax); //工作线程,io线程
Console.WriteLine($ "【自定义】最大 workerThreadsMax:{workerThreadsMax} completionPortThreadsMax:{completionPortThreadsMax}" );
}
|
线程池线程等待
看了前面 ThreadPool 相关的讲解,有小伙伴可能会发现,我们一直没有说等待线程,那 ThreadPool 有相关的 API 吗?答案:没有
但可以通过 ManualResetEvent 方式实现线程等待。一般来说不建议线程等待,二般情况也不建议。应为线程池里面,线程数量有限,写代码无意间造成的线程等待没有释放,一旦线程池线程耗尽就会形成死锁。除非非得等待情况,但记得一定要释放等待,多多检查代码。
例如:线程等待,ManualResetEvent 初始化为 false,Set() 方法会设置为 true,WaitOne() 方法会检查 ManualResetEvent 对象是否为 true,如果不为会一直等待,如果为 true 会直接过去
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public static void Dosome()
{
Console.WriteLine($ "Task Start ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Thread.Sleep(5 * 1000); // 模拟任务耗时
Console.WriteLine($ "Task End ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
}
static void Main( string [] args)
{
Console.WriteLine($ "Main 方法开始,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
ManualResetEvent manualResetEvent = new ManualResetEvent( false );
ThreadPool.QueueUserWorkItem(x =>
{
Dosome();
manualResetEvent.Set(); // 会变成 true
});
manualResetEvent.WaitOne();
Console.WriteLine($ "Main 方法结束,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Console.ReadLine();
}
|
启动程序,可以看到主线程 1 等待 子线程 3 执行完成后,在执行了 Main 方法结束代码
例如:线程耗尽形成死锁,首先对线程池线程数量进行了限制,最大为 10 个线程。接着我们循环启动 18 个线程工作,且让前 18 个线程形成等待。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
Console.WriteLine($ "Main 方法开始,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
ThreadPool.SetMinThreads(4, 4);
ThreadPool.SetMaxThreads(10, 10);
ThreadPool.GetMinThreads( out int workerThreadsMin, out int completionPortThreadsMin); //工作线程,io线程
Console.WriteLine($ "【自定义】最小 workerThreadsMin:{workerThreadsMin} completionPortThreadsMin:{completionPortThreadsMin}" );
ThreadPool.GetMaxThreads( out int workerThreadsMax, out int completionPortThreadsMax); //工作线程,io线程
Console.WriteLine($ "【自定义】最大 workerThreadsMax:{workerThreadsMax} completionPortThreadsMax:{completionPortThreadsMax}" );
ManualResetEvent manualResetEvent = new ManualResetEvent( false );
for ( int i = 0; i < 20; i++)
{
int k = i;
ThreadPool.QueueUserWorkItem((x) =>
{
Console.WriteLine(k);
if (k < 18)
{
manualResetEvent.WaitOne();
}
else
{
manualResetEvent.Set();
}
});
}
manualResetEvent.WaitOne();
Console.WriteLine($ "Main 方法结束,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Console.ReadLine();
|
启动程序,可以看到,当开启 10 个线程后,程序就已经不再运行了。这是当程循环开启第 11 个子线程时,发现线程池里面没有线程了,就会一直等待,这样一个状态就是死锁。
线程回调
讲到现在,细心的小伙伴会发现一直没有说线程回调,即当子线程执行一个任务完成后,再执行一个任务。其实 Thread 与 ThreadPool 都没有回调,但是可以创造出 Callback,那就是包一层,如果不行那就再包一层。
Thread
例如:创建一个普通方法 ThreadWithCallback 传入两个委托参数,一个实际任务,一个 Callback。接着在内部使用 Thread 开启一个新的线程,执行 action、callback 方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
private static void ThreadWithCallback(Action action, Action callback)
{
Thread thread = new Thread(() =>
{
action.Invoke();
callback.Invoke();
});
thread.Start();
}
static void Main( string [] args)
{
Console.WriteLine($ "Main 方法开始,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
ThreadWithCallback(() =>
{
Console.WriteLine($ "action,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
}, () =>
{
Console.WriteLine($ "callback,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
});
Console.WriteLine($ "Main 方法结束,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Console.ReadLine();
}
|
启动程序,可以看到 action 执行后,再执行了 callback
ThreadPool
例如:创建一个普通方法 ThreadWithCallback 传入两个委托参数,一个实际任务,一个 Callback。接着在内部使用 ThreadPool 开启一个新的线程,执行 action、callback 方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
private static void ThreadWithCallback(Action action, Action callback)
{
ThreadPool.QueueUserWorkItem(x =>
{
action.Invoke();
callback.Invoke();
});
}
static void Main( string [] args)
{
Console.WriteLine($ "Main 方法开始,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
ThreadWithCallback(() =>
{
Console.WriteLine($ "action,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
}, () =>
{
Console.WriteLine($ "callback,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
});
Console.WriteLine($ "Main 方法结束,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Console.ReadLine();
}
|
启动程序,可以看到 action 执行后,再执行了 callback
线程返回值
讲到现在,细心的小伙伴会发现一直没有说线程返回值,在 1.0、2.0 时代的 Thread、ThreadPool 是没有提供相关 API 的。但是可以创造出来,还是包一层,如果不行那就再包一层。
Thread
例如:创建一个普通方法 ThreadWithReturnCallback 返回与入参都是 Func< T >,内部启用一个 Thread 执行委托,return 一个带返回值的委托且 Thread 的线程等待放置里面。使用时给 ThreadWithReturnCallback 方法传入带返回值的委托即可,因为 ThreadWithReturnCallback 方法返回值也是委托,所以要想获得结果需要在外部 Invoke 一下,这个 Invoke 操作会卡主线程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
private static Func<T> ThreadWithReturnCallback<T>(Func<T> func)
{
T t = default (T);
Thread thread = new Thread(() =>
{
t = func.Invoke();
});
thread.Start();
return () =>
{
thread.Join();
return t;
};
}
static void Main( string [] args)
{
Console.WriteLine($ "Main 方法开始,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Func< int > func = ThreadWithReturnCallback< int >(() =>
{
return DateTime.Now.Millisecond;
});
int iResult = func.Invoke();
Console.WriteLine(iResult);
Console.WriteLine($ "Main 方法结束,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Console.ReadLine();
}
|
ThreadPool
例如:创建一个普通方法 ThreadPoolWithReturnCallback 返回与入参都是 Func< T >,使用 QueueUserWorkItem 方法启动线程执行委托,因为 ThreadPool 本身并未提供线程等待方法,所以这里使用 ManualResetEvent 进行线程等待,return 一个带返回值的委托且 ManualResetEvent WaitOne 线程等待放置里面。使用时给 ThreadPoolWithReturnCallback 方法传入带返回值的委托即可,因为 ThreadPoolWithReturnCallback 方法返回值也是委托,所以要想获得结果需要在外部 Invoke 一下,这个 Invoke 操作会卡主线程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
private static Func<T> ThreadPoolWithReturnCallback <T>(Func<T> func)
{
T t = default (T);
ManualResetEvent manualResetEvent = new ManualResetEvent( false );
ThreadPool.QueueUserWorkItem(x =>
{
t = func.Invoke();
manualResetEvent.Set(); // 会变成 true
});
return () =>
{
manualResetEvent.WaitOne();
return t;
};
}
static void Main( string [] args)
{
Console.WriteLine($ "Main 方法开始,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Func< int > func = ThreadPoolWithReturnCallback < int >(() =>
{
return DateTime.Now.Millisecond;
});
int iResult = func.Invoke();
Console.WriteLine(iResult);
Console.WriteLine($ "Main 方法结束,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Console.ReadLine();
}
|
线程池线程重用
在 1.0 时代的 Thread 每次创建实例都会向操作系统申请线程,2.0 时代的 ThreadPool 每次使用 QueueUserWorkItem 都会向线程池拿取线程,并不会向操作系统申请线程。所以,使用 ThreadPool 创建线程的效率是高于 Thread 的。
例如:我们开启三波线程执行任务,执行相同的任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
static void Main( string [] args)
{
Console.WriteLine($ "Main 方法开始,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}\n" );
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "张三,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "李四,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "王五,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "麻溜,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
Thread.Sleep(1000);Console.WriteLine();
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "张三,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "李四,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "王五,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "麻溜,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
Thread.Sleep(1000); Console.WriteLine();
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "张三,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "李四,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "王五,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}" ); });
ThreadPool.QueueUserWorkItem(t => { Console.WriteLine($ "麻溜,任务处理完成。ThreadId:{Thread.CurrentThread.ManagedThreadId}\n" ); });
Thread.Sleep(1000);
Console.WriteLine($ "Main 方法结束,ThreadId:{Thread.CurrentThread.ManagedThreadId},DateTime:{DateTime.Now.ToLongTimeString()}" );
Console.ReadLine();
}
|
启动程序,第一波的时候启用了 3、4、6、7,第二波重用了第一波的 6、7、第三波重用了第一、第二波的 3、4、5、8。其中未重用的呢,是线程并未回收(回收需要时间),所以未重用。
扩展知识-委托线程
委托的 BeginInvoke 方法使用的是线程池的线程,在任务执行完成后,子线程时不会被立马回收的,除非调用 EndInvoke 可以立马结束子线程回到线程池,利于线程更好的重用。
例如:BeginInvoke 线程不能立马被回收重用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
static void Main( string [] args)
{
Action< int > action = x =>
{
Console.WriteLine($ "我是 {x},Thread:{Thread.CurrentThread.ManagedThreadId}" );
};
for ( int i = 0; i < 5; i++)
{
action.BeginInvoke(i, null , null );
}
Console.ReadLine();
}
|
启动线程,并发五次,分别启用了4、5、7、8、9,五个线程
例如:EndInvoke 线程更好重用,BeginInvoke 方法的第二个参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
static void Main( string [] args)
{
Action< int > action = x =>
{
Console.WriteLine($ "我是 {x},Thread:{Thread.CurrentThread.ManagedThreadId}" );
};
for ( int i = 0; i < 5; i++)
{
action.BeginInvoke(i, e => { action.EndInvoke(e); }, null );
}
Console.ReadLine();
}
|
启程序,可以看到并发 5 次只使用了,线程 3 与 8。
到此这篇关于C# 异步多线程入门到精通之ThreadPool篇的文章就介绍到这了
原文链接:https://blog.csdn.net/weixin_46785144/article/details/121104117