线程
线程也被称为轻量级进程lightweight process ,LWP,线程是CPU独立调度和分派的基本单位,同一个进程中的多个线程将共享该进程中的全部系统资源,多线程共享堆heap资源,c#程序默认有一个主线程,辅助线程 worker thread ,与主线程一起执行任务,辅助线程主要做计算操作,IO线程主要做输入输出的操作
进程
process进程类,程序与进程没有一一对应关系,进程是程序在计算机市的一次执行活动,进程可以分为用户进程和系统进程,进程可以分为用户进程和系统进程,同一个进程中的uoge线程有各自的调用栈(call stack),自己的寄存器环境(register context)
进程与线程的关系
进程与线程池关系:每个进程一个线程池ThreadPool
单线程
只有一个线程的程序,什么时候用单线程比较好:计算密集型的操作,因为CPU的分片操作会浪费计算时间,一次算完比较快
多线程
线程池
为什么会有线程池?为了优化线程创建和销毁的资源消耗,创建和销毁影响程序性能
LOCK
lock(x),x需要是一个对象, 是全局变量
首先要明白为什么上面这段话能够锁定代码,其中的奥妙就是X这个对象,事实上X是任意一种引用类型,它在这儿起的作用就是任何线程执行到lock(X)时候,X需要独享才能运行下面的代码,若假定现在有3个线程A,B,C都执行到了lock(X)而ABC因为此时都占有X,这时ABC就要停下来排个队,一个一个使用X,从而起到在下面的代码块内只有一个线程在运行(因为此时只有一个线程独享X,其余两个在排队),所以这个X必须是所有要执行临界区域代码进程必须共有的一个资源,从而起到抑制线程的作用。
lock关键字可以用来确保代码块完成运行而不被其他线程中断。语句以lock开头,在参数后面还有一个只能由一个线程执行的代码块。
lock 是一个语法糖,lock等于monitor+异常处理,lock=安全的monitor,lock关键字就是用monitor类来实现的
Monitor类
1.Monitor类可以防止多个线程同时执行代码块
2.Monitor方法允许一个且仅一个线程继续执行后面的语句,其他所有线程都将被阻止,直到执行语句的线程调用Exit
3.这与使用lock关键字一样,事实上,lock关键字就是用monitor类来实现的
Object ss= new Object();
Monitor.Enter(ss);
try { // 需要执行的代码 }
finally{ Monitor.Exit(ss);} // 退出线程锁定
waitHandle.waitone
waitHandle.waitany
waitHandle.waitall
创建线程 Thread ThreadStart
class Program
{
const int res = 1000;
static void Main(string[] args)
{
ThreadStart threadstart = DoWork;
Thread thread = new Thread(threadstart);
thread.Start();
for (int i = 0; i < res; i++)
{
Console.Write("-");
}
thread.Join(); //
Console.ReadKey();
}
static void DoWork()
{
for (int i = 0; i < res; i++)
{
Console.Write("+");
}
}
//1.其中thread.Join()方法会造成当前进程(主进程)等待,直到其他正在执行的进程结束
//2.thread.IsBackGround = true; 将当前进程设置为后台进程
//3.thread.Priority = ThreadPriority.Highest ; 将进程的优先级设置为最高级(当然还有其他枚举值)
//4.Console.WriteLine(thread.ThreadState) 输出当前进程的状态
/
public static void CallToChildThread()
{
Console.WriteLine("Child thread starts");
}
public static void CallToParentThread()
{
Console.WriteLine("Parent thread starts");
}
static void Main(string[] args)
{
ThreadStart childref = new ThreadStart(CallToChildThread); // 创建线程的委托,并将需要调用的方法赋给委托
childref += CallToParentThread; // 赋值新的方法给委托
Console.WriteLine("In Main: Creating the Child thread");
Thread childThread = new Thread(childref);
childThread.Start();
Console.ReadKey();
}
锁定线程
class Program
{
static List<int> numbers = new List<int>();
static object locker = new object();
static void Main(string[] args)
{
numbers.Add(0);
Thread t1 = new Thread(GetNum);
t1.Start();
Thread t2 = new Thread(SetNum);
t2.Start();
Console.ReadKey();
}
static void GetNum()
{
lock (locker)
{
Console.WriteLine("t1->" + numbers[0]); // -> 0
Thread.Sleep(1000);
Console.WriteLine("t1->" + numbers[0]); // -> 0
}
}
static void SetNum()
{
lock (locker)
{
numbers[0] = 2;
Console.WriteLine("t2->" + numbers[0]); // ->2
}
}
}
}
管理线程 Thread.Sleep()
Console.WriteLine("this is a sleep function test");
Thread.Sleep(5000);
Console.WriteLine("this is new thread function");
//注意:避免在正式的生产代码中使用Sleep()函数
//1.没有参数就是没有延迟时间设置,相当于没有写
//2.使用sleep(时间设定值)来同步的程序被成为”穷人的同步“
终止线程 Thread.Abort()
ThreadStart ts = new ThreadStart(Speak);
Thread aa = new Thread(ts);
aa.Start();
aa.Abort();
ts += Speak2;
aa.Start(); // 这个会报错,因为已经被终止的线程无法再开启
// 注意:避免在正式的生产代码中使用Abort()函数,因为可能造成不可预测的结果,造成程序不稳定
ThreadPool线程池
如果池中的现场都被长时间运行或者I/O受限的工作占用了,正在排队的工作必然会延迟。所以在高性能程序设计的时候,这个ThreadPool和Thread只作为实现细节使用
const int res = 1000;
static void Main(string[] args)
{
ThreadPool.QueueUserWorkItem(DoWork,"sss"); // 可以加个逗号传参数进去
for (int i = 0; i < res; i++)
{
Console.Write("-");
}
Console.ReadKey();
}
static void DoWork(object ss) // 方法的参数必须是一个,且只能是可以转换为object的类型
{
for (int i = 0; i < res; i++)
{
Console.Write("+");
}
}
TPL ( Task Parallel Library ) 任务并行库
有长时间运行或者I/O受限的工作的需求时,使用TPL构建高级抽象。
1.TPL提供了一个能代表异步工作的对象,还提供了相应的API以便与工作进行交互。
(类比委托,委托封装了方法,但它是同步的)
Task
Task.Run方法
Task.Wait方法
Task tt = Task.Run(
() =>
{
for (int count = 0; count < res; count++)
{
Console.Write("-");
}
}
);
tt.Wait(); // 当前线程等待tt线程结束后再执行
// Task.WaitAll(tt); // 另一种写法
for (int i = 0; i < res; i++)
{
Console.Write("+");
}
Console.ReadKey();
Task.ContiuneWith()方法
Console.WriteLine("Before");
Task task1 = Task.Run(
() => { Console.WriteLine("Start with ....."); }
).ContinueWith((a) => { Console.WriteLine("continuing A ....."); }); // 这里面的的a其实是Task a,大概是方便lambda内部的函数调用吧
Task task2 = task1.ContinueWith(
(a) => { Console.WriteLine("continuing B ....."); }
);
Task task3 = task1.ContinueWith(
(a) => { Console.WriteLine("continuing C ....."); }
);
Task.WaitAll(task2, task3);
Console.WriteLine("Finsihed");
Console.ReadKey();
AppDomain (这个CLR VIA C#中有详细讲解,不过现在看不懂)
1.一个AppDomain中的代码创建的对象不能由另一个AppDomain中的代码直接访问
2.AppDomain可以卸载
3.AppDomain可以单独保护。AppDomain在创建后,会应用一个权限集,它决定了在这个AppDomain中运行的程序集的最大权限
4.AppDomain可以单独实施配置。AppDomain在创建后,会关联一组配置设置。这些设置主要影响CLR在AppDomain中加载程序集的方式。这些设置涉及搜索路径,版本绑定重定向,卷影复制及加载器优化
AppDomain vs 进程
AppDomain被创建在进程中,一个进程内可以有多个AppDomain。一个AppDomain只能属于一个进程。
2.AppDomain vs 线程
其实两者本来没什么好对比的。AppDomain是个静态概念,只是限定了对象的边界;线程是个动态概念,它可以运行在不同的AppDomain