线程的四种状态

合集下载

Linux线程的状态与调度

Linux线程的状态与调度1,线程的⽣命周期线程从创建、运⾏到结束总是处于下⾯五个状态之⼀：新建状态、就绪状态、运⾏状态、阻塞状态及死亡状态。

1.新建状态(New)：当⽤new操作符创建⼀个线程时，例如new Thread(r)，线程还没有开始运⾏，此时线程处在新建状态。

当⼀个线程处于新⽣状态时，程序还没有开始运⾏线程中的代码2.就绪状态(Runnable)⼀个新创建的线程并不⾃动开始运⾏，要执⾏线程，必须调⽤线程的start()⽅法。

当线程对象调⽤start()⽅法即启动了线程，start()⽅法创建线程运⾏的系统资源，并调度线程运⾏run()⽅法。

当start()⽅法返回后，线程就处于就绪状态。

处于就绪状态的线程并不⼀定⽴即运⾏run()⽅法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运⾏线程。

因为在单CPU的计算机系统中，不可能同时运⾏多个线程，⼀个时刻仅有⼀个线程处于运⾏状态。

因此此时可能有多个线程处于就绪状态。

对多个处于就绪状态的线程是由Java运⾏时系统的线程调度程序(thread scheduler)来调度的。

3.运⾏状态(Running)当线程获得CPU时间后，它才进⼊运⾏状态，真正开始执⾏run()⽅法.4. 阻塞状态(Blocked)线程运⾏过程中，可能由于各种原因进⼊阻塞状态:1>线程通过调⽤sleep⽅法进⼊睡眠状态；2>线程调⽤⼀个在I/O上被阻塞的操作，即该操作在输⼊输出操作完成之前不会返回到它的调⽤者；3>线程试图得到⼀个锁，⽽该锁正被其他线程持有；4>线程在等待某个触发条件；......所谓阻塞状态是正在运⾏的线程没有运⾏结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进⼊运⾏状态。

5. 死亡状态(Dead)有两个原因会导致线程死亡：1) run⽅法正常退出⽽⾃然死亡，2) ⼀个未捕获的异常终⽌了run⽅法⽽使线程猝死。

线程练习题——精选推荐

线程练习题答：有两种实现方法，分别是继承Thread类与实现Runnable接口用synchronized关键字修饰同步方法反对使用stop，是因为它不安全。

它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。

结果很难检查出真正的问题所在。

suspend方法容易发生死锁。

调用suspend 的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。

此时，其他任何线程都不能访问锁定的资源，除非被”挂起”的线程恢复运行。

对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。

所以不应该使用suspend，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。

若标志指出线程应该挂起，便用wait命其进入等待状态。

若标志指出线程应当恢复，则用一个notify重新启动线程。

2、sleep 和 wait 有什么区别?答：sleep是线程类的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。

调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法后本线程才进入对象锁定池准备获得对象锁进入运行状态。

3、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

答：如果数据将在线程间共享。

例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

4、启动一个线程是用run还是start?答：启动一个线程是调用start方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。

JAVA语言与面向对象程序设计期末复习题

JAVA语言与面向对象程序设计期末复习题2011年上（一）单项选择题（二） 1．对象是构成现实世界的一个独立单位，它具有自己的静态特征和（）特征。

A. 颜色B. 动态C. 状态D. 重量2．使用JDK编译ja v a程序时使用的命令是（）。

A. javaB. javacC. appletviewerD. javadoc3．在Java程序中包含主方法的类被称为主类，主方法的访问控制修饰符（)。

A. privateB. protectedC. publicD. static4．在类的定义中，若需要把一个标识符定义为常量，则使用的修饰符为（）。

A. constB. finalC. staticD. class5．在程序中声明包的语句关键字为（）。

A. volatileB. packC. importD. package6．在一个方法的方法头（声明）中向调用它的上一层方法抛出异常的子句关键字为（）。

A. catchB. throwC. throwsD. finally7．在类定义首部的语法格式中，（）不能作为其中的修饰符。

A. publicB. protectdC. extendsD. abstract8．下列哪个类不是异常类的父类？（）。

A. ErrorB. ThrowableC. ExceptionD. Object9．下面的关键字（）与异常处理无关。

A. throwB. throwsC. importD. finally10．在读字节文件Employee.dat 时，使用该文件作为参数的类是（）。

A. BufferedReaderB. DataInputStreamC. DataOutputStreamD. FileInputStream（二）填空题1．Java类库也称为Java API，它是Application Programming Interface的缩写，中文含义为________。

2．Java语言中用于修饰类的成员具有保护或私有访问属性的关键字分别为________和________。

多线程之线程状态，状态切换种类及代码实例

多线程之线程状态，状态切换种类及代码实例线程的六种基本状态为:1.NEW（刚新建）2.Runable（可运⾏）3.Blocked（被阻塞）4.Waiting ( 等待 )5.Timed waiting (计时等待)6.Terminated (被终⽌，即执⾏完毕或线程死亡)以上为线程调度的基本知识需求，接下来进⼊线程的各个状态的流程细节。

线程执⾏实例：单线程，直接不中断执⾏，直⾄执⾏完毕public class Demo1 {static class Thread1 extends Thread{@Overridepublic void run() {int i=0;while (i++<10){System.out.println("now i = "+i);}}}public static void main(String[] args) {Thread1 t1 = new Thread1();t1.start();}}输出为：now i = 1now i = 2now i = 3now i = 4now i = 5now i = 6now i = 7now i = 8now i = 9now i = 10Process finished with exit code 0这是⼀个基本的线程执⾏，可以说是最最最最简单的线程执⾏，它没有线程切换的过程。

那么线程的切换有哪⼏种呢？⾸先直接上状态和状态切换总览图图看不清，可以在新⽹页中打开，⽬前没有找到好办法能让这么⼤内容的图⼆、线程切换的种类从上图看，有三种：第⼀种：由锁竞争带来的线程阻塞，如何重新启动被阻塞的线程第⼆种：在线程进⼊等待状态后，如何唤醒该线程第三种：在线程线程休眠时，如何重新唤醒该线程其中，第⼀种是在多条线程竞争锁产⽣的，是由于锁的机制⽽导致的线程问题，第⼆种和第三种是对某条线程独⽴进⾏的控制，是程序员⾃⼰主动控制的。

线程死锁的四个必要条件

线程死锁的四个必要条件在多线程编程中，线程死锁是一种常见的问题。

它指的是两个或多个线程互相等待对方释放资源而陷入的一种僵局。

线程死锁的出现会导致程序无法继续执行，造成严重的影响。

为了避免线程死锁的出现，我们需要了解它的四个必要条件。

1. 互斥条件互斥条件指的是线程在执行时所需要的资源必须是排他性的，即不能同时被多个线程占用。

如果多个线程同时占用了同一个资源，那么就会出现资源竞争的问题，从而导致死锁的出现。

解决方法：可以通过使用锁来实现资源的互斥访问，使得同一时间只有一个线程能够访问该资源。

2. 请求与保持条件请求与保持条件指的是线程在执行时会请求一些其他线程所占用的资源，并且保持自己持有的资源不释放。

如果多个线程同时持有自己的资源并请求其他线程的资源，那么就会出现死锁的情况。

解决方法：可以通过一次性获取所有需要的资源来避免请求与保持条件的出现，或者在获取资源之前先释放已有的资源。

3. 不剥夺条件不剥夺条件指的是线程在执行时所持有的资源不能被其他线程剥夺，只能由持有该资源的线程自行释放。

如果一个线程持有了某个资源而不释放，其他线程无法剥夺该资源，就会出现死锁的情况。

解决方法：可以通过设置优先级或者时间限制等方式来避免不剥夺条件的出现。

4. 循环等待条件循环等待条件指的是多个线程之间形成了一个循环等待的环路，每个线程都在等待下一个线程所持有的资源。

如果该环路中的所有线程都不释放自己所持有的资源，那么就会出现死锁的情况。

解决方法：可以通过破坏环路来避免循环等待条件的出现，比如按照资源的编号来获取资源，或者按照一定的顺序获取资源。

线程死锁的出现需要满足以上四个条件，只要破坏其中任意一个条件就可以避免死锁的出现。

在进行多线程编程时，需要注意线程之间的资源访问问题，避免出现死锁的情况。

线程的状态及sleep、wait等方法的区别

线程的状态及sleep、wait等⽅法的区别1、创建状态使⽤ new 关键字和 Thread 类或其⼦类建⽴⼀个线程对象后，该线程对象就处于新建状态。

它保持这个状态直到程序 start() 这个线程。

2、就绪状态当线程对象调⽤了start()⽅法之后，该线程就进⼊就绪状态。

就绪状态的线程处于就绪队列中，要等待JVM⾥线程调度器的调度。

3、运⾏状态如果就绪状态的线程获取 CPU 资源，就可以执⾏ run()，此时线程便处于运⾏状态。

处于运⾏状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

4、堵塞状态如果⼀个线程执⾏了sleep（睡眠）、suspend（挂起）等⽅法，失去所占⽤资源之后，该线程就从运⾏状态进⼊阻塞状态。

在睡眠时间已到或获得设备资源后可以重新进⼊就绪状态。

可以分为三种：等待阻塞：运⾏状态中的线程执⾏ wait() ⽅法，使线程进⼊到等待阻塞状态。

同步阻塞：线程在获取 synchronized同步锁失败(因为同步锁被其他线程占⽤)。

其他阻塞：通过调⽤线程的 sleep() 或 join() 发出了 I/O请求时，线程就会进⼊到阻塞状态。

当sleep() 状态超时，join() 等待线程终⽌或超时，或者 I/O 处理完毕，线程重新转⼊就绪状态。

5、死亡状态⼀个运⾏状态的线程完成任务或者其他终⽌条件发⽣时，该线程就切换到终⽌状态。

1、sleep()使当前线程（即调⽤该⽅法的线程）暂停执⾏⼀段时间，让其他线程有机会继续执⾏，但它并不释放对象锁。

也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。

注意该⽅法要捕捉异常。

例如有两个线程同时执⾏(没有synchronized)⼀个线程优先级为MAX_PRIORITY，另⼀个为MIN_PRIORITY，如果没有Sleep()⽅法，只有⾼优先级的线程执⾏完毕后，低优先级的线程才能够执⾏；但是⾼优先级的线程sleep(500)后，低优先级就有机会执⾏了。

线程的几种状态

线程的⼏种状态线程在⼀定条件下，状态会发⽣变化。

线程⼀共有以下⼏种状态：1、新建状态(New)：新创建了⼀个线程对象。

2、就绪状态(Runnable)：线程对象创建后，其他线程调⽤了该对象的start()⽅法。

该状态的线程位于“可运⾏线程池”中，变得可运⾏，只等待获取CPU的使⽤权，即在就绪状态的进程除CPU之外，其它的运⾏所需资源都已全部获得。

3、运⾏状态(Running)：就绪状态的线程获取了CPU，执⾏程序代码。

4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使⽤权，暂时停⽌运⾏。

直到线程进⼊就绪状态，才有机会转到运⾏状态。

阻塞的情况分三种：①.等待阻塞：运⾏的线程执⾏wait()⽅法，该线程会释放占⽤的所有资源，JVM会把该线程放⼊“等待池”中。

进⼊这个状态后，是不能⾃动唤醒的，必须依靠其他线程调⽤notify()或notifyAll()⽅法才能被唤醒，②.同步阻塞：运⾏的线程在获取对象的同步锁时，若该同步锁被别的线程占⽤，则JVM会把该线程放⼊“锁池”中。

③.其他阻塞：运⾏的线程执⾏sleep()或join()⽅法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。

当sleep()状态超时、join()等待线程终⽌或者超时，或者I/O处理完毕时，线程重新转⼊就绪状态。

5、死亡状态(Dead)：线程执⾏完了或者因异常退出了run()⽅法，该线程结束⽣命周期。

线程变化的状态转换图如下：PS：拿到对象的锁标记，即为获得了对该对象(临界区)的使⽤权限。

即该线程获得了运⾏所需的资源，进⼊“就绪状态”，只需获得CPU，就可以运⾏。

因为当调⽤wait()后，线程会释放掉它所占有的“锁标志”，所以线程只有在此获取资源才能进⼊就绪状态。

下⾯作下解释：①.线程的实现有两种⽅式，⼀是继承Thread类，⼆是实现Runnable接⼝，但不管怎样，当我们new了这个对象后，线程就进⼊了初始状态；②.当该对象调⽤了start()⽅法，就进⼊就绪状态；③.进⼊就绪后，当该对象被操作系统选中，获得CPU时间⽚就会进⼊运⾏状态；④.进⼊运⾏状态后情况就⽐较复杂；（1）run()⽅法或main()⽅法结束后，线程就进⼊终⽌状态；（2）当线程调⽤了⾃⾝的sleep()⽅法或其他线程的join()⽅法，进程让出CPU，然后就会进⼊阻塞状态（该状态既停⽌当前线程，但并不释放所占有的资源，即调⽤sleep()函数后，线程不会释放它的“锁标志”。

线程阻塞的原因有哪些

线程阻塞的原因有哪些线程阻塞是指一个线程无法继续执行下去的状态，它可以由多种原因引起。

下面是一些常见的线程阻塞的原因：1.等待输入/输出：当一个线程从外部获取输入或者向外部发送输出时，如果输入/输出操作比较耗时，那么线程将会被阻塞，直到输入/输出操作完成。

2. 睡眠状态：线程可以通过调用`Thread.sleep(`方法来进入睡眠状态，这会使线程在指定的时间内暂停执行。

在这段时间内，线程被阻塞，并且不会占用CPU资源。

3.等待其他线程完成：当一个线程调用另一个线程的`join(`方法时，它将会等待被调用线程执行完毕，然后再继续执行。

如果被调用线程还没有执行完毕，调用线程将会被阻塞。

4.等待锁释放：当一个线程尝试获取一个被其他线程持有的锁时，它将会被阻塞，直到获得锁的线程释放锁。

5.等待条件满足：线程可以通过调用`wait(`方法来等待一些条件满足。

当条件不满足时，线程将会被阻塞。

直到其他线程调用该对象的`notify(`或`notifyAll(`方法，通知等待线程可以继续执行。

6.等待资源可用：当线程尝试获得系统资源，但是系统资源已经被其他线程占用时，线程将会被阻塞，直到资源变得可用。

7.等待信号量：当线程尝试获取一个信号量时，如果信号量的资源已经被其他线程占用完毕，那么线程将会被阻塞，直到有其他线程释放信号量。

8.等待网络连接建立：当一个线程尝试与其他进程或者远程服务建立网络连接时，如果连接过程比较耗时，线程将会被阻塞。

9.等待锁资源：当一个线程尝试获取一个锁资源时，如果锁已经被其他线程占用，那么线程将会被阻塞，直到其他线程释放该锁。

10.等待用户输入：当一个线程等待用户输入时，线程将会被阻塞，直到用户输入完毕。

总结来说，线程阻塞的原因可以归结为以下几个方面：输入/输出操作、睡眠状态、等待其他线程完成、等待锁释放、等待条件满足、等待资源可用、等待信号量、等待网络连接建立、等待锁资源、等待用户输入等。

线程的6种状态

线程的6种状态线程的 6 种状态就像⽣物从出⽣到长⼤、最终死亡的过程⼀样，线程也有⾃⼰的⽣命周期，在 Java 中线程的⽣命周期中⼀共有 6 种状态。

new（新创建）Runnable（可运⾏）Blocked（被阻塞）Waiting（等待）Timed Waiting（计时等待）Terminated（被终⽌）如果想要确定线程当前的状态，可以通过 getState() ⽅法，并且线程在任何时刻只可能处于 1 种状态。

New 新创建下⾯我们逐个介绍线程的 6 种状态，如图所⽰，⾸先来看下左上⾓的 New 状态。

New 表⽰线程被创建但尚未启动的状态：当我们⽤ new Thread() 新建⼀个线程时，如果线程没有开始运⾏ start() ⽅法，所以也没有开始执⾏ run() ⽅法⾥⾯的代码，那么此时它的状态就是 New。

⽽⼀旦线程调⽤了 start()，它的状态就会从 New 变成 Runnable，也就是状态转换图中中间的这个⼤⽅框⾥的内容。

Runnable 可运⾏Java 中的 Runable 状态对应操作系统线程状态中的两种状态，分别是 Running 和 Ready，也就是说，Java 中处于 Runnable 状态的线程有可能正在执⾏，也有可能没有正在执⾏，正在等待被分配 CPU 资源。

所以，如果⼀个正在运⾏的线程是 Runnable 状态，当它运⾏到任务的⼀半时，执⾏该线程的 CPU 被调度去做其他事情，导致该线程暂时不运⾏，它的状态依然不变，还是Runnable，因为它有可能随时被调度回来继续执⾏任务。

阻塞状态接下来，我们来看下 Runnable 下⾯的三个⽅框，它们统称为阻塞状态，在 Java 中阻塞状态通常不仅仅是 Blocked，实际上它包括三种状态，分别是 Blocked(被阻塞）、Waiting(等待）、Timed Waiting(计时等待），这三种状态统称为阻塞状态，下⾯我们来看看这三种状态具体是什么含义。

操作系统_苏州大学中国大学mooc课后章节答案期末考试题库2023年

操作系统_苏州大学中国大学mooc课后章节答案期末考试题库2023年1.以下有关内核线程的论述，正确的是（）。

参考答案:内核线程由内核进行创建和撤销_内核线程由内核完成线程调度_内核线程由内核管理2.引入线程后，处理机只在线程间切换。

参考答案:错误3.Java中的线程有四种状态，分别是：可运行（Runable）、就绪（Ready）、阻塞（Blocked）、死亡（Dead）。

参考答案:错误4.程序开发者必须创建一个线程去管理内存的分配。

参考答案:错误5.Unix的exec创建的进程可以和创建它的父进程共享各类资源，从而使得它的创建、切换成本较低。

参考答案:错误6.为了照顾紧迫型进程，应采用（）调度策略。

参考答案:PR7.可能存在饥饿问题的调度算法有（）。

参考答案:PR_SJF8.在页式存储管理中，引入快表可以减少每一次的内存访问时间。

参考答案:错误9.用户程序中使用的从零地址开始的地址编号是逻辑地址。

参考答案:正确10.内存管理的目的是（）。

参考答案:进行存储保护_提高内存数据访问的速度_提高内存利用率11.离散内存分配技术包括（）。

参考答案:段页式_分段_分页12.存在外碎片的存储管理方式有（）。

参考答案:可变分区分配_段式存储管理13.把内存中暂时不能运行的进程或者暂时不用的程序和数据，调出到外存上的备份区，以便腾出足够的内存空间，再把已具备运行条件的进程或进程所需的程序或数据，调入内存。

这种技术是（）。

参考答案:交换14.一个32位地址的计算机使用两级页表。

虚拟地址被分成9位的顶级页表域、11位的二级页表域和一个偏移量，页面大小是（）。

参考答案:4KB15.分页存储管理中的页表由（）建立参考答案:操作系统16.TLB在计算机系统中是用于（）。

参考答案:地址变换17.在页式存储管理中，为了实现主存的空间分配，应设置（）。

参考答案:页表18.在RR算法中，时间片越小越好。

参考答案:错误19.SJF算法可以获得最小的响应时间。

程序员面试题及答案_程序员经典面试题及答案

程序员面试题及答案_程序员经典面试题及答案1、垃圾回收的优点和原理。

并考虑2种回收机制。

Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。

由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。

垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。

垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。

回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收2、请说出你所知道的线程同步的方法。

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

leep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedE某ception异常。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

3、你所知道的集合类都有哪些主要方法最常用的集合类是Lit和Map。

Lit的具体实现包括ArrayLit和Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。

Lit适用于按数值索引访问元素的情形。

Map提供了一个更通用的元素存储方法。

Map集合类用于存储元素对(称作“键”和“值”)，其中每个键映射到一个值。

4、描述一下JVM加载cla文件的原理机制JVM中类的装载是由ClaLoader和它的子类来实现的,JavaClaLoader 是一个重要的Java运行时系统组件。

java多线程试题-答案

多线程一．选择题1.下列说法中错误的一项是（A）A.线程就是程序B.线程是一个程序的单个执行流B.多线程是指一个程序的多个执行流D.多线程用于实现并发2.下列哪个一个操作不能使线程从等待阻塞状态进入对象阻塞状态（D）A.等待阴塞状态下的线程被notify()唤B.等待阻塞状态下的纯种被interrput()中断C.等待时间到D.等待阻塞状态下的线程调用wait()方法3.下列哪个方法可以使线程从运行状态进入其他阻塞状态（A）A.sleepB.waitC.yieldD.start4.下列说法中错误的一项是（D）A.一个线程是一个Thread类的实例B.线程从传递给纯种的Runnable实例run()方法开始执行C.线程操作的数据来自Runnable实例D.新建的线程调用start()方法就能立即进入运行状态5.下列关于Thread类提供的线程控制方法的说法中，错误的一项是（D）A.在线程A中执行线程B的join()方法，则线程A等待直到B执行完成B.线程A通过调用interrupt()方法来中断其阻塞状态C.若线程A调用方法isAlive()返回值为true，则说明A正在执行中D.currentThread()方法返回当前线程的引用6.下列说法中，错误的一项是（）A.对象锁在synchronized()语句执行完之后由持有它的线程返还B.对象锁在synchronized()语句中出现异常时由持有它的线程返还C.当持有锁的线程调用了该对象的wait()方法时，线程将释放其持有的锁D.当持有锁的线程调用了该对象的构造方法时，线程将释放其持有的锁7.下面的哪一个关键字通常用来对对象的加锁，从而使得对对象的访问是排他的 AA.sirialize B transient C synchronized D static二．填空题1. 在操作系统中，被称做轻型的进程是线程2. 多线程程序设计的含义是可以将一个程序任务分成几个并行的任务3. 在Java程序中，run()方法的实现有两种方式：实现Runnable接口和继承Thread类4 .多个线程并发执行时，各个线程中语句的执行顺序是确定的，但是线程之间的相对执行顺序是不确定的6.Java中的对象锁是一种独占的排他锁7.程序中可能出现一种情况：多个线种互相等待对方持有的锁，而在得到对方的锁之前都不会释放自己的锁，这就是死锁8.线程的优先级是在Thread类的常数MIN_PRIORITY 和MAX_PRIORITY之间的一个值9.处于新建状态的线程可以使用的控制方法是start() 和stop() 。

线程的几种实现方式

线程的几种实现方式
线程的实现方式有以下几种：
1. 现成线程：由操作系统直接支持的线程。

多个现成线程可以并发执行，可以共享进程所拥有的资源，如内存空间、文件句柄等。

2. 用户级线程：线程的实现不依赖于操作系统的内核，而完全由用户程序自己实现的线程，它能够提高应用程序的并发性，但是无法实现多处理器环境下的真正并发执行。

3. 轻量级进程（LWP）：操作系统提供的对线程的抽象，每个轻量级进程包含一个或多个现成线程，LWP可以直接调用内核提供的线程控制函数，而无需进入内核态。

4. Fibers：一种轻量级协程，可以在调度程序的支持下实现用户级线程。

Fibers通过协作式调度实现，实现了单线程的非阻塞I/O 操作，提高了应用程序的并发性和效率。

5. 异步编程模型：在异步编程模型中，应用程序不需要创建线程，而是基于事件机制实现异步I/O操作，提高了应用程序的并发性和响应速度。

各种线程类型的特点和比较

各种线程类型的特点和比较线程是操作系统中独立调度的最小单位，可以并发执行多个线程。

不同类型的线程具有不同的特点和用途，在使用线程进行多任务处理时，需要根据具体的需求选择适当的线程类型。

本文将介绍常见的线程类型，包括用户线程、内核线程、守护线程、工作线程和GUI线程，并对它们的特点和比较进行详细讨论。

1. 用户线程（User Thread）用户线程是由用户空间的线程库实现和管理的线程，通过用户级调度来进行线程切换。

用户线程的特点如下：-线程创建和销毁的开销较小，因为这些操作不需要内核参与。

-调度和切换的性能较好，因为只需要用户空间内线程库的支持。

-线程的数量不受内核线程数量的限制，可以根据应用需要创建非常多的用户线程。

然而，用户线程也存在一些问题：-用户线程的调度只在用户空间内进行，不能利用多核处理器进行并行执行。

-在一个用户线程阻塞时，整个进程的其他用户线程都会被阻塞，影响整体性能。

-由于没有内核的参与，用户线程无法利用内核的一些特性和功能，如同步原语、信号量等。

2. 内核线程（Kernel Thread）内核线程是由操作系统内核创建和管理的线程，通过内核级调度来进行线程切换。

内核线程的特点如下：-内核线程的调度和切换由操作系统内核控制，能够充分利用多核处理器进行并行执行。

-内核线程可以利用操作系统提供的各种特性和功能，如同步原语、信号量等。

-内核线程的阻塞不会影响其他线程的执行，提高了并发处理的效率。

然而，内核线程也有一些缺点：-内核线程的创建和销毁开销较大，需要操作系统参与。

-内核线程数量受操作系统限制，不适合创建大量的线程。

-内核线程的调度和切换开销较大，影响了系统性能。

3. 守护线程（Daemon Thread）守护线程是一种在后台运行的线程，它的任务通常是为其他线程提供服务、执行一些常驻任务等。

守护线程的特点如下：-守护线程在没有其他用户线程需要运行时，会自动退出。

-守护线程的优先级较低，不会影响其他线程的执行。

java多线程试题_答案

java多线程试题_答案多线程一、多项选择题1.下列说法中错误的一项是（a）a.线程就是程序b、线程是程序的单个执行流b.多线程是指一个程序的多个执行流d.多线程用于实现并发2.以下哪项操作不能使线程从等待阻塞状态（d）a.b.c.d进入对象阻塞状态等待阴塞状态下的线程被notify()唤等待处于阻塞状态的纯种被interput（）中断。

等待时间到了等待阻塞状态下的线程调用wait()方法c、屈服d.start3.以下哪种方法可以使线程从运行状态进入其他阻塞状态（a）a.sleepbwait4。

以下陈述之一是错误的一个线程是一个thread类的实例线程从传递给purebreed runnable实例的run（）方法执行c.线程操作的数据来自runnable实例d.新建的线程调用start()方法就能立即进入运行状态5.在以下关于thread类提供的线程控制方法的语句中，错误之一是（d）A.B在线程a中执行线程b的join()方法，则线程a等待直到b执行完成线程a通过调用interrupt()方法来中断其阻塞状态c、如果线程a调用的isalive（）的返回值为true，则表示a正在执行。

d.currentthread（）方法在以下语句中返回当前线程的引用，其中一个错误是（）A。

在执行synchronized（）语句后，持有对象锁的线程将对象锁返回给B.C对象锁在synchronized()语句中出现异常时由持有它的线程返还当持有锁的线程调用对象的wait（）方法时，该线程将释放其持有的锁d.当持有锁的线程调用了该对象的构造方法时，线程将释放其持有的锁7.以下哪个关键字通常用于锁定对象，以便对对象的访问是独占的AA Sirilizeb2。

在操作系统中填充空白1，称为轻量级的过程是线程。

dstatic2.多线程编程的含义是，一个程序任务可以分为多个并行任务3.在Java程序中，有两种方法可以实现run（）方法：实现runnable接口和遵循确定的，但是线程类4.多个线程并发执行时，各个线程中语句的执行顺序是线程之间的相对执行顺序是模棱两可的6.java中的对象锁是一种独占的排他锁7.程序中可能存在这样一种情况：多行等待另一方持有的锁，但得到了另一方的锁min_priority和max_priority之前都不会释放自己的锁，这就是死锁8.线程优先级是线程类中的一个常量之间的一个值9.处于新建状态的线程可以使用的控制方法是start()和stop()。

VB.NET中多线程程序开发之线程状态

要想了解线程控制，首先需要知道线程的状态。

在 Thread 类中提供了一个名为 ThreadState 的实例属性。

这个属性是枚举类型的，它的成员如下表：成员说明Unstarted线程上的 Thread.Start 还未被调用Running 已调用 Thread.Start，且线程未被阻塞，也没有ThreadAbortException 处于挂起状态Aborted Stopped 状态AbortRequested 已调用 Thread.Abort，但还未收到处于挂起状态的ThreadAbortException Stopped 线程已经停止Suspended线程已经被挂起SuspendRequested线程已被要求挂起WaitJoinSleep线程被阻塞，阻塞原因可能是 Wait、Sleep 或Join下面来对上述成员作简单解释：1、 Unstarted：所有托管线程的初始状态。

处于这个状态的线程仅占用内存，不占用 CPU 的资源，因此，理论上可创建无数个这种状态的线程。

2、 Running：当前线程已经由其它线程在其上执行 Thread.Start。

前面已经提到，这样状态的线程在 Windows 中最大数目为 2000 个。

3、 Suspended：已启动，但不处于活动状态。

4、 WaitJoinSleep：线程的这种状态说明已被阻塞，原因有三种：a. 线程等待一个或多个对象(Wait)，主要用于同步构造；b. 线程在特定的时间段内处于休眠状态(Sleep)；c. 线程在等待另一个线程结束(Join) 需要要说明的是一个线程不能使另一个线程进入此状态，线程只能在自己的要求下进入此状态。

5、 Stopped：已正常结束，线程死亡，不能再被启动。

6、 Aborted：同 Stopped 状态一样，不过它是由于非正常结束而产生的一种状态。

任务挂起

在多任务实时系统中，任务状态有四种：①执行状态（execute），表示正在执行中这种状态的任务只能有一个，由优先数决定。

②挂起状态（suspend）表示暂时停止。

机器正在进行输入输出等待或事件等待，所有任务一旦处于挂起状态，机器就在操作系统内循环。

③就绪状态（ready）表示准备完了，一旦来通知就可以继续执行，或者由于优先数高的任务先执行，而优先数低的处于执行等待状态。

④静止状态（dormant）或称潜伏状态，作为任务已经消除，不能执行的状态。

所有的任务都处于静止状态时，表示该程序执行完毕。

转载请注明来自：.cn/Knowledge/nPost/nPost_52144.htmuC/OS-II任务挂起和任务延时的异同：同：二者都使任务进入等待状态。

处于等待状态的任务不处于就绪状态，任务在就绪任务表中登记的就绪标志被取消，任务不可能被调度。

异：挂起的任务只能在其他任务中通过调用恢复函数OSTaskResume()使其恢复为就绪状态，否则将不可能再次被运行（因为它没有就绪），而延时的任务可以在延时时间到时自动恢复就绪状态，即使没有其他任务调用取消延时函数OSTimeDlyResume()。

任务挂起是怎么回事就相当于操作系统中将进程挂起的操作，可以查看itron的源代码，只要有操作系统的原理知识就可以解决了。

itron里边的任务有三个状态1 run2 ready3 (广义挂起)3.1 waiting3.2 suspended3.3 dormant3.4 no-existing一个任务可以在三个状态之间切换，再具体可以看相关资料ready到waiting，，一个task在ready下时，这个task其实是可以执行的，但是有比他优先级更高的task在执行，当前task只好reay.这个task需要等待某一事件的发生比如说一个semaphone，他就跳转到waiting. waiting到ready，这个semaphone解除了，当前task又从waiting跳转到ready。