一、Task类简介:

Task类是在.NET Framework 4.0中提供的新功能,主要用于异步操作的控制。它比Thread和ThreadPool提供了更为强大的功能,并且更方便使用。

Task和Task<TResult>类:前者接收的是Action委托类型;后者接收的是Func<TResult>委托类型。

任务Task和线程Thread的区别:

1、任务是架构在线程之上。也就是说任务最终还是要抛给线程去执行,它们都是在同一命名空间System.Threading下。

2、任务跟线程并不是一对一的关系。比如说开启10个任务并不一定会开启10个线程,因为使用Task开启新任务时,是从线程池中调用线程,这点与

ThreadPool.QueueUserWorkItem类似。

    二、Task的创建

    2.1创建方式1:调用构造函数

    class Program
{
static void Main(string[] args)
{
#region 工作者线程:使用任务实现异步
ThreadPool.SetMaxThreads(, );
PrintMessage("Main thread start.");
//调用构造函数创建Task对象
Task<int> task = new Task<int>(n => AsyncMethod((int)n), ); //启动任务
task.Start();
//等待任务完成
task.Wait();
Console.WriteLine("The method result is: " + task.Result);
Console.ReadLine();
#endregion
} /// <summary>
/// 打印线程池信息
/// </summary>
/// <param name="data"></param>
private static void PrintMessage(string data)
{
//获得线程池中可用的工作者线程数量及I/O线程数量
ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber); Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n",
data,
Thread.CurrentThread.ManagedThreadId,
Thread.CurrentThread.IsBackground.ToString(),
workThreadNumber.ToString(),
ioThreadNumber.ToString());
} /// <summary>
/// 异步方法
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
private static int AsyncMethod(int n)
{
Thread.Sleep();
PrintMessage("Asynchoronous method."); int sum = ;
for (int i = ; i < n; i++)
{
//运算溢出检查
checked
{
sum += i;
}
} return sum;
}
}

2.2创建方式2:任务工厂

    class Program
{
static void Main(string[] args)
{
#region 工作者线程:使用任务工厂实现异步
////无参无返回值
//ThreadPool.SetMaxThreads(1000, 1000);
//Task.Factory.StartNew(() => PrintMessage("Main thread."));
//Console.Read(); //有参有返回值
ThreadPool.SetMaxThreads(, );
PrintMessage("Main thread start.");
var task = Task.Factory.StartNew(n => AsyncMethod((int)n), );
//等待任务完成
task.Wait();
Console.WriteLine("The method result is: " + task.Result);
Console.ReadLine();
#endregion
} /// <summary>
/// 打印线程池信息
/// </summary>
/// <param name="data"></param>
private static void PrintMessage(string data)
{
//获得线程池中可用的工作者线程数量及I/O线程数量
ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber); Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n",
data,
Thread.CurrentThread.ManagedThreadId,
Thread.CurrentThread.IsBackground.ToString(),
workThreadNumber.ToString(),
ioThreadNumber.ToString());
} /// <summary>
/// 异步方法
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
private static int AsyncMethod(int n)
{
Thread.Sleep();
PrintMessage("Asynchoronous method."); int sum = ;
for (int i = ; i < n; i++)
{
//运算溢出检查
checked
{
sum += i;
}
} return sum;
}
}

2.3创建方式3:Run方法

    class Program
{
static void Main(string[] args)
{
#region 工作者线程:使用Task.Run实现异步
ThreadPool.SetMaxThreads(, );
PrintMessage("Main thread start.");
var task = Task.Run(() => AsyncMethod());
//等待任务完成
task.Wait();
Console.WriteLine("The method result is: " + task.Result);
Console.ReadLine();
#endregion
} /// <summary>
/// 打印线程池信息
/// </summary>
/// <param name="data"></param>
private static void PrintMessage(string data)
{
//获得线程池中可用的工作者线程数量及I/O线程数量
ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber); Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n",
data,
Thread.CurrentThread.ManagedThreadId,
Thread.CurrentThread.IsBackground.ToString(),
workThreadNumber.ToString(),
ioThreadNumber.ToString());
} /// <summary>
/// 异步方法
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
private static int AsyncMethod(int n)
{
Thread.Sleep();
PrintMessage("Asynchoronous method."); int sum = ;
for (int i = ; i < n; i++)
{
//运算溢出检查
checked
{
sum += i;
}
} return sum;
}
}

三、Task的简略生命周期

    可通过Status属性获取。

状态 说明
Created 表示默认初始化任务,但是工厂及Run创建方式会直接跳过。
WaitingToRun 表示等待任务调度器分配线程给任务执行。
RanToCompletion 表示任务执行完毕。

    四、Task的控制

方法名 说明
Task.Wait 如task1.Wait();就是等待task1任务的执行,执行完成后状态变为Completed。
Task.WaitAll 等待所有的任务执行完毕。
Task.WaitAny 等待任意一个任务完成后就继续向下执行。
Task.ContinueWith 上一个任务执行完成后自动启动下一个任务,实现任务的按序进行。
CancellationTokenSource 通过其token来取消一个Task。

    4.1、组合任务

    class Program
{
public static void Main()
{
#region 工作者线程:Task组合任务
//创建一个任务
Task<int> task = new Task<int>(() =>
{
int sum = ;
Console.WriteLine("使用任务实现异步。");
for (int i = ; i < ; i++)
{
sum += i;
}
return sum;
});
//任务启动并安排到任务队列等待执行(System.Threading.Tasks.TaskScheduler)
task.Start();
//任务完成时执行处理
Task cwt = task.ContinueWith(t =>
{
Console.WriteLine("任务的执行结果:{0}", t.Result.ToString());
});
task.Wait();
cwt.Wait();
Console.ReadLine();
#endregion
}
}

运行结果如下:

4.2、串行任务

    class Program
{
public static void Main()
{
#region 工作者线程:Task串行任务
//堆栈
ConcurrentStack<int> stack = new ConcurrentStack<int>(); //t1最早串行
var t1 = Task.Factory.StartNew(() =>
{
stack.Push();
stack.Push();
}); //t2、t3并行执行
var t2 = t1.ContinueWith(t =>
{
stack.TryPop(out int result);
Console.WriteLine("Task t2 result={0},thread id is {1}.", result, Thread.CurrentThread.ManagedThreadId);
});
var t3 = t1.ContinueWith(t =>
{
stack.TryPop(out int result);
Console.WriteLine("Task t3 result={0},thread id is {1}.", result, Thread.CurrentThread.ManagedThreadId);
}); //等待t2、t3执行完毕
Task.WaitAll(t2, t3); //t4串行执行
var t4 = Task.Factory.StartNew(() =>
{
Console.WriteLine("The stack count={0},thread id is {1}.", stack.Count, Thread.CurrentThread.ManagedThreadId);
});
t4.Wait(); Console.ReadLine();
#endregion
}
}

运行结果如下:

4.3、子任务

    class Program
{
public static void Main()
{
#region 工作者线程:Task子任务
Task<string[]> parent = new Task<string[]>(state =>
{
Console.WriteLine(state);
string[] result = new string[];
//创建并启动子任务
new Task(() => { result[] = "子任务1。"; }, TaskCreationOptions.AttachedToParent).Start();
new Task(() => { result[] = "子任务2。"; }, TaskCreationOptions.AttachedToParent).Start();
return result;
}, "我是父任务,我创建了2个子任务,它们执行完后我才会结束执行。");
//任务完成时执行处理
parent.ContinueWith(t =>
{
Array.ForEach(t.Result, r => Console.WriteLine(r));
});
//启动父任务
parent.Start();
parent.Wait();
Console.ReadLine();
#endregion
}
}

运行结果如下:

4.4、动态并行任务

    /// <summary>
/// 结点类
/// </summary>
class Node
{
public Node Left { get; set; }
public Node Right { get; set; }
public string Text { get; set; }
} class Program
{
public static void Main()
{
#region 工作者线程:Task动态并行任务
Node root = GetNode();
DisplayTree(root);
Console.ReadLine();
#endregion
} /// <summary>
/// GetNode方法
/// </summary>
/// <returns></returns>
static Node GetNode()
{
Node root = new Node
{
Left = new Node
{
Left = new Node
{
Text = "L-L"
},
Right = new Node
{
Text = "L-R"
},
Text = "L"
},
Right = new Node
{
Left = new Node
{
Text = "R-L"
},
Right = new Node
{
Text = "R-R"
},
Text = "R"
},
Text = "Root"
};
return root;
} /// <summary>
/// DisplayTree方法
/// </summary>
/// <param name="root"></param>
static void DisplayTree(Node root)
{
var task = Task.Factory.StartNew
(
() =>
DisplayNode(root),
CancellationToken.None,
TaskCreationOptions.None,
TaskScheduler.Default
);
task.Wait();
} /// <summary>
/// DisplayNode方法
/// </summary>
/// <param name="current"></param>
static void DisplayNode(Node current)
{ if (current.Left != null)
{
Task.Factory.StartNew
(
() =>
DisplayNode(current.Left),
CancellationToken.None,
TaskCreationOptions.AttachedToParent,
TaskScheduler.Default
);
}
if (current.Right != null)
{
Task.Factory.StartNew
(
() =>
DisplayNode(current.Right),
CancellationToken.None,
TaskCreationOptions.AttachedToParent,
TaskScheduler.Default
);
Console.WriteLine("The current node text={0},thread id is {1}.", current.Text, Thread.CurrentThread.ManagedThreadId);
}
}
}

运行结果如下:

4.5、取消任务

    class Program
{
static void Main(string[] args)
{
#region 取消任务
ThreadPool.SetMaxThreads(, );
PrintMessage("Main thread start.");
CancellationTokenSource cts = new CancellationTokenSource(); //调用构造函数创建Task对象,将一个CancellationToken传给Task构造器从而使Task和CancellationToken关联起来。
Task<int> task = new Task<int>(n => AsyncMethod(cts.Token, (int)n), ); //启动任务
task.Start();
//延迟取消任务
Thread.Sleep(); //取消任务
cts.Cancel();
Console.WriteLine("The method result is: " + task.Result);
Console.ReadLine();
#endregion
} /// <summary>
/// 打印线程池信息
/// </summary>
/// <param name="data"></param>
private static void PrintMessage(string data)
{
//获得线程池中可用的工作者线程数量及I/O线程数量
ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber); Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n",
data,
Thread.CurrentThread.ManagedThreadId,
Thread.CurrentThread.IsBackground.ToString(),
workThreadNumber.ToString(),
ioThreadNumber.ToString());
} /// <summary>
/// 异步方法
/// </summary>
/// <param name="ct"></param>
/// <param name="n"></param>
/// <returns></returns>
private static int AsyncMethod(CancellationToken ct, int n)
{
Thread.Sleep();
PrintMessage("Asynchoronous method."); int sum = ;
try
{
for (int i = ; i < n; i++)
{
//当CancellationTokenSource对象调用Cancel方法时,就会引起OperationCanceledException异常,
//通过调用CancellationToken的ThrowIfCancellationRequested方法来定时检查操作是否已经取消,
//这个方法和CancellationToken的IsCancellationRequested属性类似。
ct.ThrowIfCancellationRequested();
Thread.Sleep();
//运算溢出检查
checked
{
sum += i;
}
}
}
catch (Exception e)
{
Console.WriteLine("Exception is:" + e.GetType().Name);
Console.WriteLine("Operation is canceled.");
} return sum;
}
}

运行结果如下:

4.6、处理单个任务中的异常

    class Program
{
public static void Main()
{
#region 工作者线程:处理单个任务中的异常
try
{
Task<int> task = Task.Run(() => SingleTaskExceptionMethod("Single task.", ));
int result = task.GetAwaiter().GetResult();
Console.WriteLine("Result:{0}", result);
}
catch (Exception ex)
{
Console.WriteLine("Single task exception caught:{0}", ex.Message);
}
Console.ReadLine();
#endregion
} /// <summary>
/// SingleTaskException方法
/// </summary>
/// <param name="name"></param>
/// <param name="seconds"></param>
/// <returns></returns>
static int SingleTaskExceptionMethod(string name, int seconds)
{
Console.WriteLine("Task {0} is running on thread {1}.Is it threadpool thread?:{2}",
name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
Thread.Sleep(TimeSpan.FromSeconds(seconds));
throw new Exception("Boom.");
}
}

运行结果如下:

4.7、处理多个任务中的异常

    class Program
{
public static void Main()
{
#region 工作者线程:处理多个任务中的异常
try
{
var t1 = new Task<int>(() => MultipleTaskExceptionMethod("Multiple task 1", ));
var t2 = new Task<int>(() => MultipleTaskExceptionMethod("Multiple task 2", ));
var complexTask = Task.WhenAll(t1, t2);
var exceptionHandler = complexTask.ContinueWith
(
t =>
Console.WriteLine("Result:{0}", t.Result),
TaskContinuationOptions.OnlyOnFaulted
);
t1.Start();
t2.Start();
Task.WaitAll(t1, t2);
Console.ReadLine();
}
catch (AggregateException ex)
{
ex.Handle
(
exception =>
{
Console.WriteLine(exception.Message);
return true;
}
);
}
#endregion
} /// <summary>
/// MultipleTaskException方法
/// </summary>
/// <param name="name"></param>
/// <param name="seconds"></param>
/// <returns></returns>
static int MultipleTaskExceptionMethod(string name, int seconds)
{
Console.WriteLine("Task {0} is running on thread id {1}. Is it threadpool thread?:{2}",
name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
Thread.Sleep(TimeSpan.FromSeconds(seconds));
throw new Exception(string.Format("Task {0} Boom.", name));
}
}

运行结果如下:

4.8、Task.FromResult的应用

    class Program
{
//字典
private static readonly IDictionary<string, string> cache = new Dictionary<string, string>()
{
{"","A"},
{"","B"},
{"","C"},
{"","D"},
{"","E"},
{"","F"},
}; public static void Main()
{
#region 工作者线程:Task.FromResult的应用
Task<string> task = GetValueFromCacheMethod("");
Console.WriteLine("Result={0}", task.Result.ToString());
Console.ReadLine();
#endregion
} /// <summary>
/// GetValueFromCache方法
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
private static Task<string> GetValueFromCacheMethod(string key)
{
Console.WriteLine("GetValueFromCache开始执行……");
string result = string.Empty;
Thread.Sleep();
Console.WriteLine("GetValueFromCache继续执行……");
if (cache.TryGetValue(key, out result))
{
return Task.FromResult(result);
}
return Task.FromResult("");
}
}

运行结果如下:

4.9、使用IProgress实现异步编程的进程通知

IProgress<in T>只提供了一个方法void Report(T value),通过Report方法把一个T类型的值报告给IProgress,然后IProgress<in T>的实现类Progress<in T>的构造函数

接收类型为Action<T>的形参,通过这个委托让进度显示在UI界面中。

    class Program
{
public static void Main()
{
#region 工作者线程:使用IProgress实现异步编程的进程通知
Task task = Display();
task.Wait();
Console.ReadLine();
#endregion
} /// <summary>
/// DoProcessing方法
/// </summary>
/// <param name="progress"></param>
static void DoProcessing(IProgress<int> progress)
{
for (int i = ; i <= ; i++)
{
Thread.Sleep();
if (progress != null)
{
progress.Report(i);
}
}
} /// <summary>
/// Display方法
/// </summary>
/// <returns></returns>
static async Task Display()
{
//当前线程
var progress = new Progress<int>
(
percent =>
{
Console.Clear();
Console.Write("{0}%", percent);
}
);
//线程池线程
await Task.Run(() => DoProcessing(progress));
Console.WriteLine("");
Console.WriteLine("结束");
}
}

运行结果如下:

4.10、Factory.FromAsync的应用

(简APM模式(委托)转换为任务)(BeginXXX和EndXXX)

带回调方式:

    class Program
{
//使用委托实现异步,是使用了异步编程模型APM。
private delegate string AsynchronousTask(string threadName); public static void Main()
{
#region 工作者线程:带回调方式的Factory.FromAsync的应用
AsynchronousTask d = TestMethod;
Console.WriteLine("Option 1");
Task<string> task = Task<string>.Factory.FromAsync(d.BeginInvoke("AsyncTaskThread", Callback, "A delegate asynchronous called."), d.EndInvoke); task.ContinueWith(t => Console.WriteLine("Callback is finished,now running a continuation. Result: {0}",t.Result)); while (!task.IsCompleted)
{
Console.WriteLine(task.Status);
Thread.Sleep(TimeSpan.FromSeconds(0.5));
}
Console.WriteLine(task.Status);
Console.ReadLine();
#endregion
} /// <summary>
/// FromAsync方法
/// </summary>
/// <param name="threadName"></param>
/// <returns></returns>
private static string FromAsyncMethod(string threadName)
{
Console.WriteLine("Starting...");
Console.WriteLine("Is it threadpool thread?:{0}", Thread.CurrentThread.IsThreadPoolThread);
Thread.Sleep(TimeSpan.FromSeconds());
Thread.CurrentThread.Name = threadName;
return string.Format("Thread name:{0}", Thread.CurrentThread.Name);
} /// <summary>
/// Callback方法
/// </summary>
/// <param name="ar"></param>
private static void Callback(IAsyncResult ar)
{
Console.WriteLine("Starting a callback...");
Console.WriteLine("State passed to a callbak: {0}", ar.AsyncState);
Console.WriteLine("Is it threadpool thread?:{0}", Thread.CurrentThread.IsThreadPoolThread);
Console.WriteLine("Threadpool worker thread id: {0}",Thread.CurrentThread.ManagedThreadId);
}
}

运行结果如下:

不带回调方式:

    class Program
{
//使用委托实现异步,是使用了异步编程模型APM。
private delegate string AsynchronousTask(string threadName); public static void Main()
{
#region 工作者线程:不带回调方式的Factory.FromAsync的应用
AsynchronousTask d = FromAsyncMethod;
Task<string> task = Task<string>.Factory.FromAsync(d.BeginInvoke, d.EndInvoke, "AsyncTaskThread", "A delegate asynchronous called.");
task.ContinueWith(t => Console.WriteLine("Task is completed, now running a continuation! Result: {0}",t.Result));
while (!task.IsCompleted)
{
Console.WriteLine(task.Status);
Thread.Sleep(TimeSpan.FromSeconds(0.5));
}
Console.WriteLine(task.Status);
Console.ReadLine();
#endregion
} /// <summary>
/// FromAsync方法
/// </summary>
/// <param name="threadName"></param>
/// <returns></returns>
private static string FromAsyncMethod(string threadName)
{
Console.WriteLine("Starting...");
Console.WriteLine("Is it threadpool thread?:{0}", Thread.CurrentThread.IsThreadPoolThread);
Thread.Sleep(TimeSpan.FromSeconds());
Thread.CurrentThread.Name = threadName;
return string.Format("Thread name:{0}", Thread.CurrentThread.Name);
}
}

运行结果如下:

参考自:

https://www.cnblogs.com/kelelipeng/p/10237669.html

https://www.cnblogs.com/lonelyxmas/p/9509298.html

C#线程学习笔记七:Task详细用法的更多相关文章

  1. C#线程学习笔记九:async & await入门二

    一.异步方法返回类型 只能返回3种类型(void.Task和Task<T>). 1.1.void返回类型:调用方法执行异步方法,但又不需要做进一步的交互. class Program { ...

  2. Linux学习笔记(七) 查询系统

    1.查看命令 (1)man 可以使用 man 命令名称 命令查看某个命令的详细用法,其显示的内容如下: NAME:命令名称 SYNOPSIS:语法 DESCRIPTION:说明 OPTIONS:选项 ...

  3. Linux 学习笔记之超详细基础linux命令 Part 8

    Linux学习笔记之超详细基础linux命令 by:授客 QQ:1033553122 ---------------------------------接Part 7----------------- ...

  4. Linux 学习笔记之超详细基础linux命令 Part 2

    Linux学习笔记之超详细基础linux命令 by:授客 QQ:1033553122 ---------------------------------接Part 1----------------- ...

  5. Java IO学习笔记七:多路复用从单线程到多线程

    作者:Grey 原文地址:Java IO学习笔记七:多路复用从单线程到多线程 在前面提到的多路复用的服务端代码中, 我们在处理读数据的同时,也处理了写事件: public void readHandl ...

  6. (转)Qt Model/View 学习笔记 (七)——Delegate类

    Qt Model/View 学习笔记 (七) Delegate  类 概念 与MVC模式不同,model/view结构没有用于与用户交互的完全独立的组件.一般来讲, view负责把数据展示 给用户,也 ...

  7. Learning ROS for Robotics Programming Second Edition学习笔记(七) indigo PCL xtion pro live

    中文译著已经出版,详情请参考:http://blog.csdn.net/ZhangRelay/article/category/6506865 Learning ROS forRobotics Pro ...

  8. Typescript 学习笔记七:泛型

    中文网:https://www.tslang.cn/ 官网:http://www.typescriptlang.org/ 目录: Typescript 学习笔记一:介绍.安装.编译 Typescrip ...

  9. Linux 学习笔记之超详细基础linux命令(the end)

    Linux学习笔记之超详细基础linux命令 by:授客 QQ:1033553122 ---------------------------------接Part 14---------------- ...

随机推荐

  1. HTTPS 原理分析——带着疑问层层深入

    HTTPS 随着 HTTPS 建站的成本下降,现在大部分的网站都已经开始用上 HTTPS 协议.大家都知道 HTTPS 比 HTTP 安全,也听说过与 HTTPS 协议相关的概念有 SSL .非对称加 ...

  2. C#面向对象--命名空间

    一.在C#中,使用命名空间(Namespace)可以帮助控制自定义类型的作用范围,同时对大量的类型进行组织:使用namespace关键字声明命名空间,命名空间可以嵌套使用: namespace MyN ...

  3. Nginx-(四)基本模块2

    nginx常用模块介绍(二) ngx_http_rewrite_module模块配置 (1)       rewrite  regex  replacement [flag]; 将请求的url基于正则 ...

  4. linux alias(命令别名)

    alias:获取定义的所有命令别名 alias NAME='COMMAND':定义别名 unalias NAME:撤销别名

  5. MySQL Last_SQL_Errno: 1062----经典错误,主键冲突

    一.基础信息 1. Centos7.4 2.MySQL 5.7.21 3.基于gtid的复制 二.异常描述 误把从节点当成主节点插入一条数据,同一条数据在主.从节点插入都进行了一次插入操作,导致主键冲 ...

  6. 程序员的算法课(3)-递归(recursion)算法

    版权声明:本文为博主原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明. 本文链接:https://blog.csdn.net/m0_37609579/article/de ...

  7. 部署 kube-controller-manager 高可用集群

    目录 前言 创建kube-controller-manager证书和私钥 生成证书和私钥 将生成的证书和私钥分发到所有master节点 创建和分发kubeconfig文件 分发kubeconfig到所 ...

  8. Docker 更换国内的Hub源

    前言 通常情况下,安装的Docker默认使用的是国外的Hub源,在pull镜像的时候很慢,甚至超时了,不动了,很烦人. 更换阿里云Docker的Hub源 阿里云 - 容器Hub服务控制台:https: ...

  9. 配置aria2

    Mac 用户肯定都受够了百度网盘在自己电脑上的糟糕体验,至少我是如此:安装官方的 App,经常下载时中断,有时甚至 Bug 般连续中断,无奈使用浏览器下载,速度却是令人挠头.花点时间来配置 aria2 ...

  10. 【经验分享】linux交叉编译 - openssl动态库

    一.准备工作 1.到openssl官网下载最新版本openssl(如openssl-1.1.1d.tar.gz),上传到linux编译机上(如上传到目录/home/test下),并使用tar -xvf ...