c#多线程之线程基础
目录
- 一、简介
- 二、创建线程
- 三、暂停线程
- 四、线程等待
- 五、终止线程
- 六、检测线程状态
- 七、线程优先级
- 八、前台线程和后台线程
- 九、向线程传递参数
- 十、使用C# Lock 关键字
- 十一、使用Monitor类锁定资源
- 十二、处理异常
一、简介
1.为了防止一个应用程序控制CPU而导致其他应用程序和操作系统本身永远被挂起这一可能情况，操作系统不得不使用某种方式将物理计算分割为一些虚拟的进程，并给予每个执行程序一定量的计算能力。此外操作系统必须始终能够优先访问CPU，并能调整不同程序访问CPU的优先级。线程正式这一慨念的实现。
2.多线程优缺点：
多线程优点：可以同时执行多个计算任务，有可能提高计算机的处理能力，使得计算机每秒能执行越来越多的命令
多线程缺点：消耗大量的操作系统资源。多个线程共享一个处理器将导致操作系统忙于管理这些线程，而无法运行程序。
二、创建线程
class Program
{
static void Main(string[] args)
{
Thread t1 = new Thread(new ThreadStart(PrintNumbers));//无参数的委托，把方法的引用当做参数
t1.Start();
Thread t2 = new Thread(new ParameterizedThreadStart(PrintNumbers));//有参数的委托，把方法的引用当做参数
t2.Start(10);
Console.ReadLine();
}
static void PrintNumbers()
{
Console.WriteLine("1.Starting...");
for (int i = 0; i < 10; i++)
{
Console.WriteLine(i);
}
}
//注意：要使用ParameterizedThreadStart，定义的参数必须为object
static void PrintNumbers(object count)
{
Console.WriteLine("2.Starting...");
for (int i = 0; i < Convert.ToInt32(count); i++)
{
Console.WriteLine(i);
}
}
}
}
注释：
1.我们只需指定在不同线程运行的方法名，而C#编译器会在后台创建这些对象。
2.要使用ParameterizedThreadStart，定义的参数必须为object类型。
三、暂停线程
class Program
{
static void Main(string[] args)
{
Thread t1 = new Thread(PrintNumbersWithDelay);
t1.Start();
PrintNumbers();
Console.ReadLine();
}
static void PrintNumbers()
{
Console.WriteLine("1.Starting...");
for (int i = 0; i < 10; i++)
{
Console.WriteLine("In 1.Starting: " + i);
}
}
static void PrintNumbersWithDelay()
{
Console.WriteLine("2.Starting...");
for (int i = 0; i < 10; i++)
{
//var a = TimeSpan.FromSeconds(2);
Thread.Sleep(TimeSpan.FromSeconds(2));//暂停两秒
Console.WriteLine("In 2.Starting: " + i);
}
}
}
注释：使用Thread.Sleep(TimeSpan.FromSeconds(2));暂停线程一段时间
四、线程等待
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Starting...");
Thread t = new Thread(PrintNumbersWithDelay);
t.Start();
t.Join(); //使用Join等待t完成后，再向下执行PrintNumbers，如果注释掉输出明显不同
PrintNumbers();
Console.WriteLine("Thread Complete");
Console.ReadLine();
}
static void PrintNumbers()
{
Console.WriteLine("1.Starting...");
for (int i = 0; i < 10; i++)
{
Console.WriteLine("In 1.Starting:" + i);
}
}
static void PrintNumbersWithDelay()
{
Console.WriteLine("2.Starting...");
for (int i = 0; i < 10; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("In 2.Starting:" + i);
}
}
}
注释：使用t.Join(); 等待t完成。
五、终止线程
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Starting Program...");
Thread t1 = new Thread(PrintNumbersWithDelay);
t1.Start();
Thread.Sleep(TimeSpan.FromSeconds(7));//此时t1线程会执行7秒
t1.Abort(); //使用Abort()终止线程
Console.WriteLine("Thread t1 has been aborted");
Thread t2 = new Thread(PrintNumbers);
t2.Start();
Console.ReadLine();
}
static void PrintNumbers()
{
Console.WriteLine("1.Starting...");
for (int i = 0; i < 10; i++)
{
Console.WriteLine("In 1.Starting:" + i);
}
}
static void PrintNumbersWithDelay()
{
Console.WriteLine("2.Starting...");
for (int i = 0; i < 10; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("In 2.Starting:" + i);
}
}
}
注释：使用Thread实例的Abort方法终止线程。
六、检测线程状态
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Start Program...");
Thread t1 = new Thread(PrintNumbersWithStatus);
Thread t2 = new Thread(DoNothing);
Console.WriteLine("t1 status:" + t1.ThreadState.ToString());//获取实例线程状态
t2.Start();
t1.Start();
for (int i = 0; i < 30; i++)
{
Console.WriteLine("t1 status:" + t1.ThreadState.ToString() + "\t" + "t2 status:" + t2.ThreadState.ToString());
}
Thread.Sleep(TimeSpan.FromSeconds(7));
t1.Abort();
Console.WriteLine("thread t1 has been aborted");
Console.WriteLine("t1 status:" + t1.ThreadState.ToString());
Console.WriteLine("t2 status:" + t2.ThreadState.ToString());
Console.ReadLine();
}
private static void PrintNumbersWithStatus()
{
Console.WriteLine("1.Starting...");
Console.WriteLine("In 1.Starting t1 status:" + Thread.CurrentThread.ThreadState.ToString());//获取当前线程状态
for (int i = 0; i < 10; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("In 1.Starting:" + i);
}
}
private static void DoNothing()
{
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("t2 Console...");
}
}
注释：使用Thread.ThreadState获取线程的运行状态。ThreadState是一个C#枚举。谨记：不要在程序中使用线程终止，否则可能会出现意想不到的结果
七、线程优先级
class Program
{
static void Main(string[] args)
{
//让操作系统的所有线程运行在多个CPU核心上
Console.WriteLine($"Current thread priority: {Thread.CurrentThread.Priority}");
Console.WriteLine("Running on all cores available");//获取实例线程状态
RunThreads();
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("Running on a single Core");
//让操作系统的所有线程运行在单个CPU核心上
Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
RunThreads();
Console.ReadLine();
}
private static void RunThreads()
{
var sample = new ThreadSample();
var t1 = new Thread(sample.CountNumbers);
t1.Name = "Thread One";
var t2 = new Thread(sample.CountNumbers);
t2.Name = "Thread Two";
t1.Priority = ThreadPriority.Highest;//使用Priority设置线程的优先级
t2.Priority = ThreadPriority.Lowest;
t1.Start();
t2.Start();//此处t2优先级低于t1,t2等待t1释放资源。
Thread.Sleep(TimeSpan.FromSeconds(2));
sample.Stop();
}
}
class ThreadSample
{
private bool _isStopped = false;
public void Stop()
{
_isStopped = true;
}
public void CountNumbers()
{
long counter = 0;
while (!_isStopped)
{
counter++;
}
Console.WriteLine($"{Thread.CurrentThread.Name} with {Thread.CurrentThread.Priority} priority has a count={counter.ToString("N0")}");
}
}
注释：单核执行多线程耗费的时间比多核的多很多。
八、前台线程和后台线程
class Program
{
static void Main(string[] args)
{
var sampleForground = new ThreadSample(10);
var sampleBackground = new ThreadSample(20);
var t1 = new Thread(sampleForground.CountNumbers);//方法的引用
t1.Name = "ForegroundThread"; //没有明确声明的均为前台线程
var t2 = new Thread(sampleBackground.CountNumbers);
t2.Name = "BackgroundThread";
t2.IsBackground = true; //设置为后台线程
t1.Start();
t2.Start();
Console.ReadLine();
}
}
class ThreadSample
{
private readonly int _iteration;
public ThreadSample(int iteration)
{
_iteration = iteration;
}
public void CountNumbers()
{
for (int i = 0; i < _iteration; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(0.5));
Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
}
}
}
注释：进程会等待所有的前台线程完成后再结束工作，但是如果只剩下后台线程，则会直接结束工作。
九、向线程传递参数
class Program
{
static void Main(string[] args)
{
ThreadSample sample = new ThreadSample(5);
Thread t1 = new Thread(sample.CountNumbers);
t1.Name = "ThreadOne";
t1.Start();
t1.Join();
Console.WriteLine("--------------------------");
Thread t2 = new Thread(Count);
t2.Name = "ThreadTwo";
t2.Start(3);
t2.Join();
Console.WriteLine("--------------------------");
//使用lambda表达式引用另一个C#对方的方式被称为闭包。当在lambda表达式中使用任何局部变量时，C#会生成一个类，并将该变量作为该类的一个属性，但是我们无须定义该类，C#编译器会自动帮我们实现
Thread t3 = new Thread(() => CountNumbers(5));
t3.Name = "ThreadThree";
t3.Start();
t3.Join();
Console.WriteLine("--------------------------");
int i = 10;
Thread t4 = new Thread(() => PrintNumber(i));
i = 20;
Thread t5 = new Thread(() => PrintNumber(i));
t4.Start();
t5.Start();
//t4, t5都会输出20， 因为t4，t5没有Start之前i已经变成20了
Console.ReadKey();
}
static void Count(object iterations)
{
CountNumbers((int)iterations);
}
static void CountNumbers(int iterations)
{
for (int i = 1; i <= iterations; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(0.5));
Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
}
}
static void PrintNumber(int number)
{
Console.WriteLine(number);
}
}
class ThreadSample
{
private readonly int _iteration;
public ThreadSample(int iteration)
{
_iteration = iteration;
}
public void CountNumbers()
{
for (int i = 1; i <= _iteration; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(0.5));
Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
}
}
}
十、使用C# Lock 关键字
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Incorrect Counter");
Counter c1 = new Counter();
var t1 = new Thread(() => TestCounter(c1));
var t2 = new Thread(() => TestCounter(c1));
var t3 = new Thread(() => TestCounter(c1));
t1.Start();
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();
Console.WriteLine($"Total Count: {c1.Count}");
Console.WriteLine("------------------------");
//使用LOCK关键字，Count同一时刻只允许一个线程访问
Console.WriteLine("Correct counter");
CounterWithLock c2 = new CounterWithLock();
t1 = new Thread(() => TestCounter(c2));
t2 = new Thread(() => TestCounter(c2));
t3 = new Thread(() => TestCounter(c2));
t1.Start();
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();
Console.WriteLine($"Total count:{c2.Count}");
Console.ReadLine();
}
static void TestCounter(CounterBase c)
{
for (int i = 0; i < 100000; i++)
{
c.Increment();
c.Decrement();
}
}
//子类
class Counter : CounterBase
{
public int Count { get; private set; }
//重写基类方法
public override void Decrement()
{
Count--;
}
public override void Increment()
{
Count++;
}
}
//子类
class CounterWithLock : CounterBase
{
private readonly object _asyncRoot = new object();
public int Count { get; private set; }
//重写基类方法
public override void Decrement()
{
lock (_asyncRoot)
{
Count--;
}
}
public override void Increment()
{
lock (_asyncRoot)
{
Count++;
}
}
}
//基类
abstract class CounterBase
{
public abstract void Increment();
public abstract void Decrement();
}
}
class ThreadSample
{
private readonly int _iteration;
public ThreadSample(int iteration)//构造函数
{
_iteration = iteration;
}
public void CountNumbers()
{
for (int i = 1; i <= _iteration; i++)
{
Thread.Sleep(TimeSpan.FromSeconds(0.5));
Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
}
}
}
注释：不加锁，得出的结果不确定，竞争条件下很容易出错。加锁得出的结果是正确的，但是性能受到了影响
十一、使用Monitor类锁定资源
class Program
{
static void Main(string[] args)
{
object lock1 = new object();
object lock2 = new object();
new Thread(() => LockTooMuch(lock1, lock2)).Start();
lock (lock2)
{
Thread.Sleep(1000);
Console.WriteLine("Monitor.TryEnter allows not to get stuck, returning false after a specified timeout is elapsed");
//直接使用Monitor.TryEnter, 如果在第二个参数之前还未获取到lock保护的资源会返回false
if (Monitor.TryEnter(lock1, TimeSpan.FromSeconds(5)))
{
Console.WriteLine("Acquired a protected resource successfully");
}
else
{
Console.WriteLine("Timeout acquiring a resource");
}
}
new Thread(() => LockTooMuch(lock1, lock2)).Start();
Console.WriteLine("-----------------------------");
/* 下面代码会造成死锁， 所以注释掉
lock (lock2)
{
Console.WriteLine("This will be a deadlock!");
Thread.Sleep(1000);
lock (lock1)
{
Console.WriteLine("Acquired a protected resource successfully");
}
}
*/
}
static void LockTooMuch(object lock1, object lock2)
{
lock (lock1)
{
Thread.Sleep(1000);
lock (lock2);
}
}
}
注释：Monitor.TryEnter在指定的时间内尝试获取指定对象上的排他锁
十二、处理异常
class Program
{
static void Main(string[] args)
{
Thread t = new Thread(FaultyThread);
t.Start();
t.Join();
try
{
t = new Thread(BadFaultyThread);
t.Start();
}
catch (Exception ex)
{
Console.WriteLine("We won't get here");
}
}
static void BadFaultyThread()
{
Console.WriteLine("Starting a bad faulty thread.....");
Thread.Sleep(TimeSpan.FromSeconds(2));
//这个异常主线程无法捕捉到，因为是在子线程抛出的异常。需要在子线程中加入try...catch捕获异常
throw new Exception("Boom!");
}
static void FaultyThread()
{
try
{
Console.WriteLine("Starting a faulty thread...");
Thread.Sleep(TimeSpan.FromSeconds(1));
throw new Exception("Boom!");
}
catch (Exception ex)
{
Console.WriteLine($"Exception handled: {ex.Message}");
}
}
}
到此这篇关于c#多线程之线程基础的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持我们。
相关推荐
-
C#多线程开发实战记录之线程基础
目录 前言 线程基础 1.创建线程 2.暂停线程 3.线程等待 4.线程终止 C#中的lock关键字 总结 前言 最近由于工作的需要,一直在使用C#的多线程进行开发,其中也遇到了很多问题,但也都解决了.后来发觉自己对于线程的知识和运用不是很熟悉,所以将利用几篇文章来系统性的学习汇总下C#中的多线程开发. 线程基础 "进程是操作系统分配资源的最小单元,线程是操作系统调度的最小单元" 这句话应该学习计算机的朋友或多或少都听说过,这在操作系统这门课中是很重要的一个概念. 在操作系统中可以同时
-
C# 多线程学习之基础入门
目录 同步方式 异步多线程方式 异步多线程优化 异步回调 异步信号量 异步多线程返回值 异步多线程返回值回调 线程(英语:thread)是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务.进程是资源分配的基本单位.所有与该进程有关的资源,都被记录在进程控制块PCB中.以表示该进程拥有这些资源或正在使用它们.本文以一些简单的小例子,简述如何将程序由同步方式,一步一步演变成
-
C#多线程基础知识汇总
最近自己写了个小爬虫,里面用到了多线程技术,忽然发现对此技术竟然有些陌生了,于是乎开始疯狂的去问度娘,在此记录下来,以便自己和各位小伙伴们学习. 一.什么是线程 一个应用程序就相当于一个进程,进程拥有应用程序的所有资源进程包括线程,进程的资源被线程共享,但不拥有线程.我们可以打开电脑中的任务管理器,运行的.exe都是一个进程,里面的分支是线程. 二.多线程 多线程其实就是进程中一段并行运行的代码 1. 创建并启动线程 static void Main() { //获取线程Id var threa
-
C#多线程系列之任务基础(二)
目录 判断任务状态 再说父子任务 组合任务/延续任务 复杂的延续任务 并行(异步)处理任务 并行(同步)处理任务 并行任务的 Task.WhenAny 并行任务状态 循环中值变化问题 定时任务 TaskScheduler 类 判断任务状态 属性 说明 IsCanceled 获取此 Task 实例是否由于被取消的原因而已完成执行. IsCompleted 获取一个值,它表示是否已完成任务. IsCompletedSuccessfully 了解任务是否运行到完成. IsFaulted 获取 Task
-
C#多线程系列之任务基础(一)
目录 多线程编程 多线程编程模式 探究优点 任务操作 两种创建任务的方式 Task.Run() 创建任务 取消任务 父子任务 任务返回结果以及异步获取返回结果 捕获任务异常 全局捕获任务异常 多线程编程 多线程编程模式 .NET 中,有三种异步编程模式,分别是基于任务的异步模式(TAP).基于事件的异步模式(EAP).异步编程模式(APM). 基于任务的异步模式 (TAP) :.NET 推荐使用的异步编程方法,该模式使用单一方法表示异步操作的开始和完成.包括我们常用的 async .await
-
C#多线程系列之任务基础(三)
目录 TaskAwaiter 延续的另一种方法 另一种创建任务的方法 实现一个支持同步和异步任务的类型 Task.FromCanceled() 如何在内部取消任务 Yield 关键字 补充知识点 TaskAwaiter 先说一下 TaskAwaiter,TaskAwaiter 表示等待异步任务完成的对象并为结果提供参数. Task 有个 GetAwaiter() 方法,会返回TaskAwaiter 或TaskAwaiter<TResult>,TaskAwaiter 类型在 System.Run
-
C# 异步多线程入门基础
目录 进程.线程 1. 进程 2. 线程 分时.分片 同步.异步 异步.多线程 异步多线程效率 多线程无序性 扩展 异步多线程版本 下一篇:C# 异步多线程入门到精通之Thread篇 进程.线程 1. 进程 首先了解,什么是线程? 即一个应用程序运行时,占用资源的综合是一个进程.Windows 任务管理器里面可以看到,里面一个个都是在运行的进程. 2. 线程 线程是执行流的最小单位.线程其实是看不到的,其实也可以,例如 Windows 任务管理器:正在运行 272 个进程,272 个进程运行了
-
c#多线程编程基础
无论您是为具有单个处理器的计算机还是为具有多个处理器的计算机进行开发,您都希望应用程序为用户提供最好的响应性能,即使应用程序当前正在完成其他工作.要使应用程序能够快速响应用户操作,同时在用户事件之间或者甚至在用户事件期间利用处理器,最强大的方式之一是使用多线程技术. 多线程:线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作,称为多线程.如果某个线程进行一次长延迟操作, 处理器就切换到另一个线程执行.这样,多个线程的并行(并发)执行隐藏了长延迟,提高了处理器资源利用率
-
C# 多线程编程技术基础知识入门
什么是进程? 当一个程序开始运行时,它就是一个进程,进程包括运行中的程序和程序所使用到的内存和系统资源.而一个进程又是由多个线程所组成的. 什么是线程? 线程是程序中的一个执行流,每个线程都有自己的专有寄存器(栈指针.程序计数器等),但代码区是共享的,即不同的线程可以执行同样的函数. 什么是多线程? 多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务,也就是说允许单个程序创建多个并行执行的线程来完成各自的任务. 多线程是指程序中包含多个执行流,即在一个程序中
-
c#多线程之线程基础
目录 一.简介 二.创建线程 三.暂停线程 四.线程等待 五.终止线程 六.检测线程状态 七.线程优先级 八.前台线程和后台线程 九.向线程传递参数 十.使用C# Lock 关键字 十一.使用Monitor类锁定资源 十二.处理异常 一.简介 1.为了防止一个应用程序控制CPU而导致其他应用程序和操作系统本身永远被挂起这一可能情况,操作系统不得不使用某种方式将物理计算分割为一些虚拟的进程,并给予每个执行程序一定量的计算能力.此外操作系统必须始终能够优先访问CPU,并能调整不同程序访问CPU的优先
-
java多线程之线程同步七种方式代码示例
为何要使用同步? java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查), 将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他线程的调用, 从而保证了该变量的唯一性和准确性. 1.同步方法 即有synchronized关键字修饰的方法. 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时, 内置锁会保护整个方法.在调用该方法前,需要获得内置锁,否则就处于阻塞状态. 代码
-
java多线程之线程,进程和Synchronized概念初解
一.进程与线程的概念 (1)在传统的操作系统中,程序并不能独立运行,作为资源分配和独立运行的基本单位都是进程. 在未配置 OS 的系统中,程序的执行方式是顺序执行,即必须在一个程序执行完后,才允许另一个程序执行:在多道程序环境下,则允许多个程序并发执行.程序的这两种执行方式间有着显著的不同.也正是程序并发执行时的这种特征,才导致了在操作系统中引入进程的概念. 自从在 20 世纪 60 年代人们提出了进程的概念后,在 OS 中一直都是以进程作为能拥有资源和独立运行的基本单位的.直到 20 世纪 8
-
Java多线程中线程的两种创建方式及比较代码示例
1.线程的概念:线程(thread)是指一个任务从头至尾的执行流,线程提供一个运行任务的机制,对于java而言,一个程序中可以并发的执行多个线程,这些线程可以在多处理器系统上同时运行.当程序作为一个应用程序运行时,java解释器为main()方法启动一个线程. 2.并行与并发: (1)并发:在单处理器系统中,多个线程共享CPU时间,而操作系统负责调度及分配资源给它们. (2)并行:在多处理器系统中,多个处理器可以同时运行多个线程,这些线程在同一时间可以同时运行,而不同于并发,只能多个线程共享CP
-
java并发编程专题（一）----线程基础知识
在任何的生产环境中我们都不可逃避并发这个问题,多线程作为并发问题的技术支持让我们不得不去了解.这一块知识就像一个大蛋糕一样等着我们去分享,抱着学习的心态,记录下自己对并发的认识. 1.线程的状态: 线程状态图: 1.新建状态(New):新创建了一个线程对象. 2.就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法.该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权. 3.运行状态(Running):就绪状态的线程获取了CPU,执行程序代码. 4
-
c# 面试必备线程基础知识点
线程的知识太多,知识点有深有浅,往深的研究会涉及操作系统.CPU.内存,往浅了说就是一些语法.没有一定的知识积累,很难把线程的知识写得全面,当然我也没有这个能力.所以想到一个点写一个点,尽量总结一些有用的知识点.线程是个大话题,这个系列可能会有好几遍关于线程的,先从基础的开始,热热身. 一些基础概念 线程(Thread)是操作系统能够进行运算调度的最小单位.它是进程中的实际运作单位,一个进程中可以启动多个线程,每个线程可以并行执行不同的任务.严格意义上来说,同一时间可以并行运行的线程数取决于 C
-
Java多线程之线程状态的迁移详解
一.六种状态 java.lang.Thread 的状态分为以下 6 种,它们以枚举的形式,封装在了Thread类内部: NEW:表示线程刚刚创建出来,还未启动 RUNNABLE:可运行状态,该状态的线程可以是ready或running,唯一的决定因素是线程调度器 BLOCKED:阻塞,线程正在等待一个monitor锁以便进入一个同步代码块 WAITING:等待,一种挂起等待的状态.一个线程处于waiting是为了等待其他线程执行某个特定的动作. TIMED_WAITING:定时等待. TERMI