之Thread类以及对为什么设置线程优先级

1C#对线程进行 *** 作时，通过Thread类，可以对线程进行创建、挂起、恢复、休眠、终止及设置优先级。

Thread类位于SystemThreading命名空间下，该命名空间还包含一个ThreadPool类(允许用户使用系统提供的线程池)和一个Timer类(在线程池上执行回调方法)

在线程运行期间，不同的时刻会表现为不同的状态，但它总是处于由ThreadState定义的一个或多个状态中。用户可以通过使用ThreadPriority枚举为线程定义优先级，但不能保证 *** 系统会接收该优先级

2Thread类常用的属性：

CurrentThread           获取当前正在运行的线程

IsAlive                 获取一个值，该值只是当前线程的执行状态

Name                    获取或设置线程的名称

Priority                获取或设置一个值，该值只是线程的调度优先级

ThreadState             获取一个值，该值包含当前线程的状态

3Thread类常用的方法：

Abort                   调用此方法通常会终止线程

Join                    阻止调用线程，直到某个线程终止时为止

Resume                  继续已挂起的线程

Sleep                   将当前线程阻止指定的毫秒数

Start                   使线程被安排进行执行

Suspend                 挂起线程，或者如果线程已挂起，则不起作用

4创建线程--Start()方法

创建一个线程，只需将其声明并为其提供线程起始点处的方法委托。

Thread类具有接受一个ThreadState委托或ParameterizedThreadStart委托的构造函数，该委托包装了调用Start方法时由新线程调用的方法。

只有在调用Start方法后才会创建实际的线程。Start方法的两种重载方式：

(1)导致 *** 作系统将当前实例的状态更改为ThreadStateRunning

语法：public void Start()

说明：该方法无参数，无返回值

(2)使 *** 作系统当前实例的状态更改为ThreadStateRunning，并选择线程执行所需要的方法

语法：public void Start(Object parameter)

说明：参数parameter表示一个对象，包含线程执行的方法要使用的数据

注意：如果线程已经终止，就无法通过再次调用Start方法来重新启动

5线程的挂起与恢复--Suspend方法和Resume方法

(1)Suspend方法

该方法用来挂起线程，如果线程已经挂起则不起作用

语法：public void Suspend()

说明：调用Suspend方法挂起线程时，net允许要挂起的线程再执行几个指令，目的是为了到达net认为线程可以安全挂起的状态

(2)Resume方法

该方法用来继续已挂起的线程

语法：public void Resume()

说明：通过Resume方法来恢复被暂停的线程是，无论调用了多少次Suspend方法，调用Resume方法均会使另外的线程脱离挂起状态，并导致当前线程继续执行

6线程休眠--Sleep()方法

该方法用来将当前线程阻止指定的时间，有两种重载方式

(1)将当前线程挂起指定的时间

语法：public static void Sleep(int millisecondsTimeout)

说明：参数millisecondsTimeout表示线程被阻止的毫秒数，指定零以指示应挂起此线程以使其他等待线程能够执行；指定Infinite以无限期阻止线程

(2)将当前线程阻止指定的时间

语法：public static void Sleep(TimeSpan timeout)

说明：参数timeout表示线程被阻止的时间量的TimeSpan，指定零以指示应挂起此线程以使其他等待线程能够执行；指定Infinite以无限期阻止线程

7终止线程

终止线程可以分别使用Abort方法和Join方法实现

(1)Abort方法

用来终止线程，有两种重载形式，都是引发的ThreadAbortExecption

public void Abort()--终止进程

public void Abort(Object stateInfo)--终止线程并提供有关线程终止的异常信息

参数stateInfo是一个对象，包含应用程序特定的信息(如状态)，该信息可供正被终止的线程使用

(2)Join方法

Join用来阻止调用线程，直到某个线程终止时为止。有三种重载形式

public void Join()

public bool Join(int millisecondsTimeout)

说明：参数millisecondsTimeout表示等待线程终止的毫秒数。如果线程已终止，则返回值为true，如果线程经过了millisecondsTimeout指定时间后未终止，返回值为false

public bollJoin(TimeSpan timeout)

说明：参数timeout表示等待线程终止的时间量TimeSpan。如果线程已终止，则返回值为true，如果线程经过timeout时间量之后未终止，则返回值为false

8线程的优先级

AboveNormal      可以将Thread安排在具有highest优先级线程之后，在Normal之前

BelowNormal      在Normal之后，Lowest之前

Highest          在具有任何其他优先级的线程之前

Lowest           在具有其他任何优先级的线程之后

Normal           在AboveNormal之后，BelowNormal之前。默认值。

可以通过调用线程的Priority属性来获取和设置其优先级。Priority属性用来获取或设置一个值，该值指示线程的调度优先级。

语法：public ThreadPriority Priority{get;set;}

说明：属性值是ThreadPriority枚举值之一，默认值为Normal。

实例代码：

[csharp] view plain copy

static void Main(string[] args)

{

Thread thread1 = new Thread(new ThreadStart(Thread1));  //使用自定义方法Thread1声明线程

thread1Priority = ThreadPriorityLowest;               //设置线程的调度优先级

Thread thread2 = new Thread(new ThreadStart(Thread2));  //使用自定义方法Thread2声明线程

thread1Start();                                        //开启线程一

thread2Start();                                        //开启线程二

ConsoleReadLine();

}

static void Thread1()

{

ConsoleWriteLine("线程一");

}

static void Thread2()

{

ConsoleWriteLine("线程二");

}

运行截图：

注意：这里很多人都疑惑了，既然thread1优先级比thread2优先级低，为什么还是先输出的thread1的内容呢？

其实那是因为你不了解线程的优先级实现原理

线程的优先级并不是你想象的先执行哪个后执行哪个

而是所有的线程不论优先级高低都会执行,

优先级越高表示CPU分配给该线程的时间片越多,执行时间就多

优先级越低表示CPU分配给该线程的时间片越少,执行时间就少

在软件开发行业中存在着许多的术语，比如说线程、线程池等等。今天，电脑培训就一起来了解一下，在java编程软件开发项目中都有哪些开发术语是需要我们了解的。

什么是线程

术语“线程”可以用来描述很多不同的事情。在本文中，我会使用它来代指一个逻辑线程。也就是：按照线性顺序的一系列 *** 作;一个执行的逻辑路径。CPU的每个核心只能真正并发同时执行一个逻辑线程。这就带来一个固有的问题：如果线程的数量多于内核的数量，那么有的线程必须要暂停以便于其他的线程来运行工作，当再次轮到自己的执行的时候，会将任务恢复。为了支持暂停和恢复，线程至少需要如下两件事情：

某种类型的指令指针。也就是，当我暂停的时候，我正在执行哪行代码

一个栈。也就是，我当前的状态是什么栈中包含了本地变量以及指向变量所分配的堆的指针。同一个进程中的所有线程共享相同的堆。

鉴于以上两点，系统在将线程调度到CPU上时就有了足够的信息，能够暂停某个线程、允许其他的线程运行，随后再次恢复原来的线程。这种 *** 作通常对线程来说是完全透明的。从线程的角度来说，它是连续运行的。线程能够感知到重新调度的方式是测量连续 *** 作之间的计时。

JVM使用 *** 作系统线程

尽管并非规范所要求，但是据我所知所有的现代、通用JVM都将线程委托给了平台的 *** 作系统线程来处理。在接下来的内容中，我将会使用“用户空间线程(userspacethread)”来代指由语言进行调度的线程，而不是内核/OS所调度的线程。 *** 作系统实现的线程有两个属性，这两个属性极大地限制了它们可以存在的数量;任何将语言线程和 *** 作系统线程进行1:1映射的解决方案都无法支持大规模的并发。

在JVM中，固定大小的栈

使用 *** 作系统线程将会导致每个线程都有固定的、较大的内存成本

采用 *** 作系统线程的另一个主要问题是每个OS线程都有大小固定的栈。尽管这个大小是可以配置的，但是在64位的环境中，JVM会为每个线程分配1M的栈。你可以将默认的栈空间设置地更小一些，但是你需要权衡内存的使用，因为这会增加栈溢出的风险。代码中的递归越多，就越有可能出现栈溢出。如果你保持默认值的话，那么1000个线程就将使用1GB的RAM。虽然现在RAM便宜了很多，但是几乎没有人会为了运行上百万个线程而准备TB级别的RAM。

主要内容：

进程是资源分配的最小单位，每个进程都有独立的代码和数据空间，一个进程包含 1 到 n 个线程。线程是 CPU 调度的最小单位，每个线程有独立的运行栈和程序计数器，线程切换开销小。

Java 程序总是从主类的 main 方法开始执行，main 方法就是 Java 程序默认的主线程，而在 main 方法中再创建的线程就是其他线程。在 Java 中，每次程序启动至少启动 2 个线程。一个是 main 线程，一个是垃圾收集线程。每次使用 Java 命令启动一个 Java 程序，就相当于启动一个 JVM 实例，而每个 JVM 实例就是在 *** 作系统中启动的一个进程。

多线程可以通过继承或实现接口的方式创建。

Thread 类是 JDK 中定义的用于控制线程对象的类，该类中封装了线程执行体 run() 方法。需要强调的一点是，线程执行先后与创建顺序无关。

通过 Runnable 方式创建线程相比通过继承 Thread 类创建线程的优势是避免了单继承的局限性。若一个 boy 类继承了 person 类，boy 类就无法通过继承 Thread 类的方式来实现多线程。

使用 Runnable 接口创建线程的过程：先是创建对象实例 MyRunnable，然后将对象 My Runnable 作为 Thread 构造方法的入参，来构造出线程。对于 new Thread(Runnable target) 创建的使用同一入参目标对象的线程，可以共享该入参目标对象 MyRunnable 的成员变量和方法，但 run() 方法中的局部变量相互独立，互不干扰。

上面代码是 new 了三个不同的 My Runnable 对象，如果只想使用同一个对象，可以只 new 一个 MyRunnable 对象给三个 new Thread 使用。

实现 Runnable 接口比继承 Thread 类所具有的优势：

线程有新建、可运行、阻塞、等待、定时等待、死亡 6 种状态。一个具有生命的线程，总是处于这 6 种状态之一。 每个线程可以独立于其他线程运行，也可和其他线程协同运行。线程被创建后，调用 start() 方法启动线程，该线程便从新建态进入就绪状态。

NEW 状态（新建状态） 实例化一个线程之后，并且这个线程没有开始执行，这个时候的状态就是 NEW 状态：

RUNNABLE 状态（就绪状态）：

阻塞状态有 3 种：

如果一个线程调用了一个对象的 wait 方法， 那么这个线程就会处于等待状态（waiting 状态）直到另外一个线程调用这个对象的 notify 或者 notifyAll 方法后才会解除这个状态。

run() 里的代码执行完毕后，线程进入终结状态（TERMINATED 状态）。

线程状态有 6 种：新建、可运行、阻塞、等待、定时等待、死亡。

我们看下 join 方法的使用：

运行结果：

我们来看下 yield 方法的使用：

运行结果：

线程与线程之间是无法直接通信的，A 线程无法直接通知 B 线程，Java 中线程之间交换信息是通过共享的内存来实现的，控制共享资源的读写的访问，使得多个线程轮流执行对共享数据的 *** 作，线程之间通信是通过对共享资源上锁或释放锁来实现的。线程排队轮流执行共享资源，这称为线程的同步。

Java 提供了很多同步 *** 作（也就是线程间的通信方式），同步可使用 synchronized 关键字、Object 类的 wait/notifyAll 方法、ReentrantLock 锁、无锁同步 CAS 等方式来实现。

ReentrantLock 是 JDK 内置的一个锁对象，用于线程同步（线程通信），需要用户手动释放锁。

运行结果：

这表明同一时间段只能有 1 个线程执行 work 方法，因为 work 方法里的代码需要获取到锁才能执行，这就实现了多个线程间的通信，线程 0 获取锁，先执行，线程 1 等待，线程 0 释放锁，线程 1 继续执行。

synchronized 是一种语法级别的同步方式，称为内置锁。该锁会在代码执行完毕后由 JVM 释放。

输出结果跟 ReentrantLock 一样。

Java 中的 Object 类默认是所有类的父类，该类拥有 wait、 notify、notifyAll 方法，其他对象会自动继承 Object 类，可调用 Object 类的这些方法实现线程间的通信。

除了可以通过锁的方式来实现通信，还可通过无锁的方式来实现，无锁同 CAS（Compare-and-Swap，比较和交换）的实现，需要有 3 个 *** 作数：内存地址 V，旧的预期值 A，即将要更新的目标值 B，当且仅当内存地址 V 的值与预期值 A 相等时，将内存地址 V 的值修改为目标值 B，否则就什么都不做。

我们通过计算器的案例来演示无锁同步 CAS 的实现方式，非线程安全的计数方式如下：

线程安全的计数方式如下：

运行结果：

线程安全累加的结果才是正确的，非线程安全会出现少计算值的情况。JDK 15 开始，并发包里提供了原子 *** 作的类，AtomicBoolean 用原子方式更新的 boolean 值，AtomicInteger 用原子方式更新 int 值，AtomicLong 用原子方式更新 long 值。 AtomicInteger 和 AtomicLong 还提供了用原子方式将当前值自增 1 或自减 1 的方法，在多线程程序中，诸如 ++i 或 i++ 等运算不具有原子性，是不安全的线程 *** 作之一。 通常我们使用 synchronized 将该 *** 作变成一个原子 *** 作，但 JVM 为此种 *** 作提供了原子 *** 作的同步类 Atomic，使用 AtomicInteger 做自增运算的性能是 ReentantLock 的好几倍。

上面我们都是使用底层的方式实现线程间的通信的，但在实际的开发中，我们应该尽量远离底层结构，使用封装好的 API，例如 JUC 包（javautilconcurrent，又称并发包）下的工具类 CountDownLath、CyclicBarrier、Semaphore，来实现线程通信，协调线程执行。

CountDownLatch 能够实现线程之间的等待，CountDownLatch 用于某一个线程等待若干个其他线程执行完任务之后，它才开始执行。

CountDownLatch 类只提供了一个构造器：

CountDownLatch 类中常用的 3 个方法：

运行结果：

CyclicBarrier 字面意思循环栅栏，通过它可以让一组线程等待至某个状态之后再全部同时执行。当所有等待线程都被释放以后，CyclicBarrier 可以被重复使用，所以有循环之意。

相比 CountDownLatch，CyclicBarrier 可以被循环使用，而且如果遇到线程中断等情况时，可以利用 reset() 方法，重置计数器，CyclicBarrier 会比 CountDownLatch 更加灵活。

CyclicBarrier 提供 2 个构造器：

上面的方法中，参数 parties 指让多少个线程或者任务等待至 barrier 状态；参数 barrierAction 为当这些线程都达到 barrier 状态时会执行的内容。

CyclicBarrier 中最重要的方法 await 方法，它有 2 个重载版本。下面方法用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务。

而下面的方法则是让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行任务。

运行结果：

CyclicBarrier 用于一组线程互相等待至某个状态，然后这一组线程再同时执行，CountDownLatch 是不能重用的，而 CyclicBarrier 可以重用。

Semaphore 类是一个计数信号量，它可以设定一个阈值，多个线程竞争获取许可信号，执行完任务后归还，超过阈值后，线程申请许可信号时将会被阻塞。Semaphore 可以用来 构建对象池，资源池，比如数据库连接池。

假如在服务器上运行着若干个客户端请求的线程。这些线程需要连接到同一数据库，但任一时刻只能获得一定数目的数据库连接。要怎样才能够有效地将这些固定数目的数据库连接分配给大量的线程呢？

给方法加同步锁，保证同一时刻只能有一个线程去调用此方法，其他所有线程排队等待，但若有 10 个数据库连接，也只有一个能被使用，效率太低。另外一种方法，使用信号量，让信号量许可与数据库可用连接数为相同数量，10 个数据库连接都能被使用，大大提高性能。

上面三个工具类是 JUC 包的核心类，JUC 包的全景图就比较复杂了：

JUC 包（javautilconcurrent）中的高层类（Lock、同步器、阻塞队列、Executor、并发容器）依赖基础类（AQS、非阻塞数据结构、原子变量类），而基础类是通过 CAS 和 volatile 来实现的。我们尽量使用顶层的类，避免使用基础类 CAS 和 volatile 来协调线程的执行。JUC 包其他的内容，在其他的篇章会有相应的讲解。

Future 是一种异步执行的设计模式，类似 ajax 异步请求，不需要同步等待返回结果，可继续执行代码。使 Runnable（无返回值不支持上报异常）或 Callable（有返回值支持上报异常）均可开启线程执行任务。但是如果需要异步获取线程的返回结果，就需要通过 Future 来实现了。

Future 是位于 javautilconcurrent 包下的一个接口，Future 接口封装了取消任务，获取任务结果的方法。

在 Java 中，一般是通过继承 Thread 类或者实现 Runnable 接口来创建多线程， Runnable 接口不能返回结果，JDK 15 之后，Java 提供了 Callable 接口来封装子任务，Callable 接口可以获取返回结果。我们使用线程池提交 Callable 接口任务，将返回 Future 接口添加进 ArrayList 数组，最后遍历 FutureList，实现异步获取返回值。

运行结果：

上面就是异步线程执行的调用过程，实际开发中用得更多的是使用现成的异步框架来实现异步编程，如 RxJava，有兴趣的可以继续去了解，通常异步框架都是结合远程 >

在软件开发行业中存在着许多的术语，比如说线程、线程池等等。今天，电脑培训就一起来了解一下，在java编程软件开发项目中都有哪些开发术语是需要我们了解的。

什么是线程

术语“线程”可以用来描述很多不同的事情。在本文中，我会使用它来代指一个逻辑线程。也就是：按照线性顺序的一系列 *** 作;一个执行的逻辑路径。CPU的每个核心只能真正并发同时执行一个逻辑线程。这就带来一个固有的问题：如果线程的数量多于内核的数量，那么有的线程必须要暂停以便于其他的线程来运行工作，当再次轮到自己的执行的时候，会将任务恢复。为了支持暂停和恢复，线程至少需要如下两件事情：

某种类型的指令指针。也就是，当我暂停的时候，我正在执行哪行代码

一个栈。也就是，我当前的状态是什么栈中包含了本地变量以及指向变量所分配的堆的指针。同一个进程中的所有线程共享相同的堆。

鉴于以上两点，系统在将线程调度到CPU上时就有了足够的信息，能够暂停某个线程、允许其他的线程运行，随后再次恢复原来的线程。这种 *** 作通常对线程来说是完全透明的。从线程的角度来说，它是连续运行的。线程能够感知到重新调度的方式是测量连续 *** 作之间的计时。

JVM使用 *** 作系统线程

尽管并非规范所要求，但是据我所知所有的现代、通用JVM都将线程委托给了平台的 *** 作系统线程来处理。在接下来的内容中，我将会使用“用户空间线程(userspacethread)”来代指由语言进行调度的线程，而不是内核/OS所调度的线程。 *** 作系统实现的线程有两个属性，这两个属性极大地限制了它们可以存在的数量;任何将语言线程和 *** 作系统线程进行1:1映射的解决方案都无法支持大规模的并发。

在JVM中，固定大小的栈

使用 *** 作系统线程将会导致每个线程都有固定的、较大的内存成本

采用 *** 作系统线程的另一个主要问题是每个OS线程都有大小固定的栈。尽管这个大小是可以配置的，但是在64位的环境中，JVM会为每个线程分配1M的栈。你可以将默认的栈空间设置地更小一些，但是你需要权衡内存的使用，因为这会增加栈溢出的风险。代码中的递归越多，就越有可能出现栈溢出。如果你保持默认值的话，那么1000个线程就将使用1GB的RAM。虽然现在RAM便宜了很多，但是几乎没有人会为了运行上百万个线程而准备TB级别的RAM。

itjobJava老师讲过：1)线程堆栈概述及基础知识

2)线程堆栈的生成原理以及相关工具

3)不同JVM线程堆栈的格式的差异（SunHotSpot、IBMJRE、OracalJRockit）

4)线程堆栈日志介绍以及解析方法

5)线程堆栈的分析和相关的技术

6)常见的问题模板（线程竟态、死锁、IO调用挂死、垃圾回收/问题、死循环等）

7)线程堆栈问题实例分析

我希望这一系列的培训能给你带来确实的帮助，所以请持续关注每周的文章更新。

但是如果我在学习过程中有疑问或者无法理解文章中的内容该怎么办？

不用担心，把我当做你的导师就好。任何关于线程堆栈的问题都可以咨询我（前提是问题不能太low）。请随意选择下面的几种方式与我取得联系：

1)直接本文下面发表评论（不好意思的话可以匿名）

2)将你的线程堆栈数据提交到RootCauseAnalysisforum

3)发Email给我，地址是@@hotmail

能帮我分析我们产品上遇到的问题么？

当然可以，如果你愿意的话可以把你的堆栈现场数据通过邮件或论坛RootCauseAnalysisforum发给我。处理实际问题是才是学习提升技能的王道。

我真心期望大家能够喜欢这个培训。所以我会尽我所能去为你提供高质量的材料，并回答大家的各种问题。

在介绍线程堆栈分析技术和问题模式之前，先要给大家讲讲基础的内容。所以在这篇帖子里，我将先覆盖到最基本的内容，这样大家就能更好的去理解JVM、中间件、以及JavaEE容器之间的交互。

JavaVM概述

Java虚拟机是JaveEE平台的基础。它是中间件和应用程序被部署和运行的地方。

JVM向中间件软件和你的Java/JavaEE程序提供了下面这些东西:

_（二进制形式的）Java/JavaEE程序运行环境

_一些程序功能特性和工具(IO基础设施，数据结构，线程管理，安全，监控等等)

_借助垃圾回收的动态内存分配与管理

你的JVM可以驻留在许多的 *** 作系统(Solaris,AIX,Windows等等)之上，并且能根据你的物理服务器配置，你可以在每台物理/虚拟服务器上安装1到多个JVM进程

JVM与中间件之间的交互

下面这张图展示了JVM、中间件和应用程序之间的高层交互模型。

如你所见，标准JavaEE应用程序的线程的分配实在中间件内核与JVM之间完成的。（当然也有例外，应用程序可以直接调用API来创建线程，这种做法并不常见，而且在使用的过程中也要特别的小心）

同时，请注意一些线程是由JVM内部来进行管理的，典型的例子就是垃圾回收线程，JVM内部使用这个线程来做并行的垃圾回收处理。

因为大多数的线程分配都是由JavaEE容器完成的，所以能够理解和认识线程堆栈跟踪，并能从线程堆栈数据中识别出它来，对你而言很重要这可以让你能够快速的知道JavaEE容器正要执行的是什么类型的请求

从一个线程转储堆栈的分析角度来看，你将能了解从JVM发现的线程池之间的不同，并识别出请求的类型

最后一节会向你提供对于HotSopVM而言什么是JVM线程堆栈的一个概述，还有你将会遇到的各种不同的线程而对IBMVM线程堆栈形式详细内容将会在第四节向你提供

请注意你可以从根本原因分析论坛获得针对本文的线程堆栈示例

JVM线程堆栈——它是什么

JVM线程堆栈是一个给定时间的快照，它能向你提供所有被创建出来的Java线程的完整清单

以上就是关于之Thread类以及对为什么设置线程优先级全部的内容，包括:之Thread类以及对为什么设置线程优先级、电脑培训分享关于编程术语的讲解、并发编程解惑之线程等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！