相关疑难解决方法(0)

在C#4.0中,我们已经Task在System.Threading.Tasks命名空间.之间有什么真正的改变Thread和Task.我为了学习而做了一些示例程序(帮助从MSDN获取)

Parallel.Invoke 
Parallel.For 
Parallel.ForEach 

但有很多疑问,因为这个想法并不那么清楚.

我最初在Stackoverflow中搜索了类似类型的问题但可能是这个问题标题我无法得到相同的.如果有人知道之前发布的相同类型的问题,请提供链接的参考.

我很想知道这一点,但从未真正找到答案.

我知道这是任务调度程序的一个提示,任务调度程序将在其中运行,并且任务调度程序可以(或现在将？)决定为该任务实例化非线程池线程.

我不知道(并且令人惊讶地在互联网上找不到)是一个"经验法则"何时指定一个长期运行的任务.是一秒多长？30秒？一分钟？5分钟？它是否与应用程序使用的任务量有关系？作为程序员,我应该使用线程池中的#threads进行一些计算,我创建了多少个任务,同时长时间运行了多少个任务,并根据这个来决定是否使用长时间运行的任务？

希望在这里学点东西.

有一个C#函数A(arg1, arg2)需要多次调用.为了做到这一点,我正在使用并行编程.

以下面的代码为例:

long totalCalls = 2000000;
int threads = Environment.ProcessorCount;

ParallelOptions options = new ParallelOptions(); 
options.MaxDegreeOfParallelism = threads;

Parallel.ForEach(Enumerable.Range(1, threads), options, range =>
{
    for (int i = 0; i < total / threads; i++)
    {
        // init arg1 and arg2
        var value = A(arg1, agr2);
        // do something with value
    }
});

现在的问题是,随着核心数量的增加,这不会扩大规模; 例如,在8个内核上,它使用80%的CPU,在16个内核上,它使用40-50%的CPU.我想最大限度地使用CPU.

您可能认为A(arg1, arg2)内部包含复杂的计算,但它没有任何IO或网络绑定操作,也没有线程锁定.有哪些其他可能性可以找出代码的哪一部分使其不能以100%并行的方式执行？

我也试过提高并行度,例如

int threads = Environment.ProcessorCount * 2;
// AND
int threads = Environment.ProcessorCount * 4;
// etc.

但它没有任何帮助. …

我有以下虚拟代码来测试F#中的TPL.(Mono 4.5,Xamarin工作室,四核MacBook Pro)

令我惊讶的是,所有进程都在同一个线程上完成.根本就没有并行性.

open System
open System.Threading
open System.Threading.Tasks


let doWork (num:int) (taskId:int) : unit =
    for i in 1 .. num do
        Thread.Sleep(10)
        for j in 1 .. 1000 do
            ()
        Console.WriteLine(String.Format("Task {0} loop: {1}, thread id {2}", taskId, i, Thread.CurrentThread.ManagedThreadId)) 

[<EntryPoint>]
let main argv = 

    let t2 = Task.Factory.StartNew(fun() -> doWork 10 2)
    //printfn "launched t2"
    Console.WriteLine("launched t2")
    let t1 = Task.Factory.StartNew(fun() -> doWork 8 1)
    Console.WriteLine("launched t1")
    let t3 = Task.Factory.StartNew(fun() -> doWork 10 3)
    Console.WriteLine("launched …

**最终,我将同时运行四个任务,并有另一个包含四个进度条的表单.我希望每个进度条都能更新,因为它的工作任务正在完成.

这就是我要为初学者做的事情.

我有一个表格上有一些按钮.当我点击一个我正在创建一个新任务来做一些工作.

public partial class MyMainForm : Form
{

    private void btn_doWork_Click(object sender, EventArgs e)
    {
        Task task = new Task(RunComparisons);
        task.Start();
    }

    private void RunComparisons()
    {
        int progressBarValue = 0;
        MyProgressBarForm pBar = new MyProgressBarForm(maxValue, "some text");
        pBar.ShowDialog();
        foreach(string s in nodeCollection)
        {
            //do some work here
            progressBarValue++;
            pBar.updateProgressBar(progressBarValue, "some new text");
        }
        pBar.BeginInvoke(new Action(() => pBar.Close()));
    }
}

在另一个包含带进度条的表单的类中:

public partial class MyProgressBarForm : Form
{
    public MyProgressBarForm(int maxValue, string textToDisplay)
    {
        InitializeComponent();
        MyProgressBarControl.Maximum = maxValue;
        myLabel.Text …

参考以下帖子,这使得人们相信.NET任务在没有涉及本机OS线程的情况下执行.这是真的？

Task(System.Threading.Task)和Thread之间的区别

编辑

在查看重复的问题时,我找不到直接解决实例化.NET Task类最终将在本机OS线程上执行的问题的答案.它们指的是线程,但要么不在托管和本机操作系统线程之间辨别,要么仅在托管线程之间辨别.唯一可能重复的是我自己对其中一个问题的回答.

但是在挖掘自己时,似乎没有.NET的"魔力"可以避免本机操作系统线程.Windows内核没有允许更改.这与几十年前我自己的操作系统体验一致.简而言之,没有任何人可以编写的应用程序代码不能在本机Windows操作系统线程上运行.

关于进程和线程 管理线程

也:

Windows内核内部流程架构

Windows内核的体系结构

Windows内核架构的演变

我是线程新手,我需要澄清以下情况.

我正在研究苹果推送通知服务.我的应用程序要求在向网站添加新交易时向30k用户发送通知.

我可以将30k用户分成列表,每个列表包含1000个用户并启动多个线程或可以使用任务吗？

以下方式有效吗？

if (lstDevice.Count > 0)
{

    for (int i = 0; i < lstDevice.Count; i += 2)
    {
        splitList.Add(lstDevice.Skip(i).Take(2).ToList<DeviceHelper>());
    }

    var tasks = new Task[splitList.Count];
    int count=0;
    foreach (List<DeviceHelper> lst in splitList)
    {
        tasks[count] = Task.Factory.StartNew(() =>
        {
            QueueNotifications(lst, pMessage, pSubject, pNotificationType, push);
        },
            TaskCreationOptions.None);
       count++;
    }

QueueNotification方法将遍历每个列表项并创建一个有效负载

foreach (DeviceHelper device in splitList)
{
    if (device.PlatformType.ToLower() == "ios")
    {
        push.QueueNotification(new AppleNotification()
                                    .ForDeviceToken(device.DeviceToken)
                                    .WithAlert(pMessage)
                                    .WithBadge(device.Badge)
                                     );
        Console.Write("Waiting for Queue to Finish...");
    }
}
push.StopAllServices(true);

Task在提出这个问题后，我一直在阅读有关s 的内容，发现我完全误解了这个概念。此处 和此处的最佳答案等答案 解释了这个想法，但我仍然不明白。\n所以我提出了一个非常具体的问题：CPU 上实际发生了什么执行任务时

这是我在阅读后了解到的：任务将与调用者共享 CPU 时间（假设调用者是“UI”），因此如果它是 CPU 密集型的，那么它会变慢下用户界面。如果任务不是CPU密集型的 - 它将“在后台”运行。在测试之前似乎足够清楚 \xe2\x80\xa6\xe2\x80\xa6 。下面的代码应该允许用户单击按钮，然后交替显示“已显示”和“按钮”。但实际上：表单完全繁忙（无法进行用户输入），直到“已显示”全部显示为止。

public Form1()\n{\n    InitializeComponent();\n    Shown += Form1_Shown;\n}\n\nprivate async void Form1_Shown(object sender, EventArgs e)\n{\n    await Doit("Shown");\n}\n\nprivate async Task Doit(string s)\n{\n    WebClient client = new WebClient();\n    for (int i = 0; i < 10; i++)\n    {\n        client.DownloadData(uri);//This is here in order to delay the Text writing without much CPU use.\n        textBox1.Text += s …

示例代码：

    class Program
    {
        static void sleepFunc()
        {
            int before = Thread.CurrentThread.ManagedThreadId;
            Thread.Sleep(5000);
            int after = Thread.CurrentThread.ManagedThreadId;
            Console.WriteLine($"{before} -> sleep -> {after}");
        }

        static async void delayFunc()
        {
            int before = Thread.CurrentThread.ManagedThreadId;
            await Task.Delay(5000);
            int after = Thread.CurrentThread.ManagedThreadId;
            Console.WriteLine($"{before} -> delay -> {after}");
        }
        static void Main(string[] args)
        {
            List<Thread> threads = new List<Thread>();
            for(int i = 0; i < 10; i++)
            {
                var thread = new Thread(sleepFunc);
                thread.Start();
                threads.Add(thread);
            }
            Thread.Sleep(1000); // just to separate the result sections
            for …

例如:

void Function1()
{
  Function2();
  Function3();
}

会Function3保证等到Function2每次Function1调用完成处理吗？