精华内容
下载资源
问答
  • 线程的概念以及为什么要引入线程 文章目录线程的概念以及为什么要引入线程1.线程2.为什么要引入线程 1.线程 线程是轻量级的进程,在一个进程内部可以存在一个或多个线程,进程与进程之间是不能共享内存的,进程之间...

    线程的概念以及为什么要引入线程

    1.线程

    线程是轻量级的进程,在一个进程内部可以存在一个或多个线程,进程与进程之间是不能共享内存的,进程之间的消息通信不方便,但是一个进程内部的线程之间是共享这个进程的内存空间的,线程之间通信很方便。

    2.为什么要引入线程

    如以上讲的,线程之间共享内存。比如,一个文字输入软件,其内部可以有三个线程,一个用来响应鼠标、键盘的交互线程,一个用来运算,另一个用来备份。因为进程之间不共享内存,所以不能用多个进程来实现这时就用多线程可以解决。线程之间共享内存,所以从一个线程切换到另一个线程不需要陷入内核,也不需要切换上下文,线程之间的切换比进程切换快捷。

    3.线程的状态

    线程和传统的进程一样,存在就绪、运行、阻塞、终止状态。

    4.线程的堆栈

    线程共用进程的内存空间,但是拥有自己的堆栈,在线程堆栈中有一帧,这个栈帧用来存储局部变量和返回地址,用来供线程之间的相互调用时使用。

    5.线程的创建

    线程可以调用库函数thread_create来创建一个新的线程,新线程和该线程共享内存空间,有自己独立的堆栈,线程之间不存在层次关系(父子关系),所有线程都是平等的,新线程会返回给调用的线程一个线程ID。

    6.线程的退出

    调用系统函数thread_exit使线程退出,调用之后线程消失,无法再调度。

    7.等待线程的退出

    可以调用系统函数thread_join函数等待指定线程退出之后,再运行。

    8.线程放弃CPU的使用

    线程和进程不一样,线程没有时间片的强制机制使一个线程放弃CPU的使用,让给另一个线程,要灵活使用系统函数thread_yield来使线程放弃对CPU的使用,从而让给另外的线程。

    9.用户级线程和内核级线程

    与进程相似,线程也有管理线程的线程表,线程分为用户线程和内核线程,用户线程的线程表保存在进程的存储空间里,内核线程的线程表保存在内核中。对于用户级线程来说,实现线程之间的切换不需要陷入内核,可以直接切换,但是用户级线程存在一些问题,比如只有当前运行的线程主动放弃CPU才能切换到另一个线程,没有时间片等强制措施,而内核线程的线程表存储在内核中,线程切换需要内核来管理,所以可以强制切换。另外内核线程的有一个问题,对于线程的创建和销毁,如果每次创建都要在内核中创建线程表,销毁时重置内存表,这样的代价太大。主要的做法就是,当某个线程销毁时将其标志为不可运行,但是,内核数据结构没有改变,需要创建新线程时直接重启某个旧的线程,这样的方法称为线程回收。用户级线程也可以使用线程回收,但是没有必要,因为其线程的创建和销毁不涉及内核。

    展开全文
  • 引入线程可提高程序并发执行的程度,可进一步提高系统效率 C. 线程的引入增加了程序执行时更多相关问题[单选] 离合器上安装扭转减振器是为了防止()。[判断题] 最早将社会制度的功能从性质上做这种区分的是美国社会...

    【单选题】下面的叙述中,正确的是()

    A. 线程是比进程更小的能独立运行的基本单位,可以脱离进程独立运行 B. 引入线程可提高程序并发执行的程度,可进一步提高系统效率 C. 线程的引入增加了程序执行时

    更多相关问题

    [单选] 离合器上安装扭转减振器是为了防止()。

    [判断题] 最早将社会制度的功能从性质上做这种区分的是美国社会学家默顿。

    [判断题] 最早将社会制度的功能从性质上做这种区分的是美国社会学家默顿。

    [填空题] 缩宫素酶的作用为______,其活性降低见于______、______、______

    [多选] 技术转让合同包含()合同。

    [填空题] 妊娠早期的羊水主要来自______,中期以后______为羊水的重要来源

    [单选] 着火点是能产生燃烧现象所需要的()温度。

    [多选] 生产过程一般是由许多部分组成,根据各部分在生产过程中的作用不同可划分为()。

    [多选] 在赠与合同中规定受赠人有(),赠与人可以撤销赠与。

    [填空题] 一个初级绒毛干及其分支形成一个______,一个次级绒毛干及其分支形成一个______。

    [问答题] 哪一次会议提出实行改革开放的伟大决策?

    [填空题] 胎盘的功能包括_____________、______________、___________、_________以及_________

    [填空题] 受精卵着床需经过_____、_____和_____3个阶段。

    [单选] 废气再循环的目的是净化排气中()。

    [单选] 导线振动是由线路侧面吹来的均匀微风造成的,这种风速是()m/s。

    [填空题] 受精卵着床需经过_____、_____和_____3个阶段。

    [判断题] 对于一个具有三级索引表的文件,存取一个记录需要访问三次磁盘。

    [单选] 工商银行“汇市通”业务可提供从()每日24小时外汇交易服务。

    [单选] 如果批量退货中发生实际退货商品的数量或条形码与批量退货登记表上填写的数量或条形码不相符的情况时,下列哪项操作是正确的()

    [判断题] 对于一个具有三级索引表的文件,存取一个记录需要访问三次磁盘。

    [判断题] 存取控制表是每个用户一张,表明该用户对不同文件的存取权限。

    [填空题] 受精卵着床需经过_____、_____和_____3个阶段。

    [单选] 瑞士联邦共和国实行()

    [单选] 01,11,15,30、31分区、28分区的01、92、96部门的同事收到采购发出的Bulletin后,必须在()天内将索赔退货商品送往索赔办。

    [问答题] 简述苹果施肥时期和方法

    [填空题] 低压带电作业时应站在干燥的绝缘物上进行,并戴()和安全帽。

    [单选] 01,11,15,30、31分区、28分区的01、92、96部门的同事收到采购发出的Bulletin后,必须在()天内将索赔退货商品送往索赔办。

    [判断题] SPOOLing技术可以解决进程使用设备死锁问题。

    [填空题] 胎盘合成的甾体激素有_________和__________等。

    [填空题] 胎儿附属物是指胎儿以______,包括______、______、_____和______。

    [填空题] 缩宫素酶的作用为______,其活性降低见于______、______、______

    [填空题] 孕妇血容量增加于妊娠______周达高峰,血容量增加包括______及______。

    [多选] 生产过程一般是由许多部分组成,根据各部分在生产过程中的作用不同可划分为()。

    [填空题] 妊娠______周胎儿开始出现呼吸运动,______周开始出现吞咽和排尿功能。

    [填空题] 胎儿附属物是指胎儿以______,包括______、______、_____和______。

    展开全文
  • Java线程状态及切换

    2021-03-14 18:14:45
    Java线程状态及切换一、什么是Java线程状态在Java程序中,用于描述Java线程的六种状态:新建(NEW):当前线程,刚刚新建出来,尚未启动。运行(RUNNABLE):当前线程,处于竞争CPU时间分片或已经获得CPU时间片的状态。...

    Java线程状态及切换

    一、什么是Java线程状态

    在Java程序中,用于描述Java线程的六种状态:

    新建(NEW):当前线程,刚刚新建出来,尚未启动。

    运行(RUNNABLE):当前线程,处于竞争CPU时间分片或已经获得CPU时间片的状态。

    等待(WAITTING):当前线程,处于休眠,不参与CPU时间片竞争的状态。

    定时等待(TIMED_WAITTING):当前线程,处于定时休眠,暂时不参与CPU时间片竞争的状态。

    阻塞(BLOCKED):当前线程,处于阻塞,不参与CPU时间片竞争的状态。

    终止(TERMINATED):当前线程,处于最终停止的状态。

    新建状态,只能进入运行状态。而终止状态无法再转为其他状态。

    等待/定时等待与阻塞,差别就是后者需要一个事件信号(如其他线程放弃当前线程需要的排他锁),才可以进行状态切换。当然,强行关闭也是可以的。

    Java线程的实现并不受JVM规范约束,故不同虚拟机的实现,往往不同。目前主流的HotSpot是将每个Java线程直接映射到一个操作系统的原生线程,从而由操作系统完成一系列的线程调度

    二、哪里看Java线程状态

    查看Java线程状态,主要存在三种方式:

    java.lang.Thread.State下可以直接看到Java的六种线程状态

    Java运行时,程序内部可以通过Thread.getState()获取目标线程状态

    Java运行时,程序外部可以通过jstack等工具,查看线程状态

    有关jstack等工具等使用,后续会有博客,专门阐述。

    三、什么时候变换Java线程状态

    Java线程状态的切换嘛。不啰嗦,直接上图。

    dcfab5f39579f0db7c1873330229e2e6.png

    这张图涵盖了Java线程状态切换的各类方法。相较网上一些图片,更为详尽一些。

    如果有所遗漏,可以告诉我,我会及时填补上。

    四、谁在使用Java线程状态

    日常开发中,我们并不会直接与线程状态进行交互。

    我们往往直接使用JDK包装好的工具,如JUC包下的各类工具等。

    举个栗子

    线程池中的应用

    位置:com.sun.corba.se.impl.orbutil.threadpool.ThreadPoolImpl#close

    // Note that this method should not return until AFTER all threads have died.

    public void close() throws IOException {

    // Copy to avoid concurrent modification problems.

    List copy = null;

    synchronized (workersLock) {

    copy = new ArrayList<>(workers);

    }

    for (WorkerThread wt : copy) {

    wt.close();

    while (wt.getState() != Thread.State.TERMINATED) {

    try {

    wt.join();

    } catch (InterruptedException exc) {

    wrapper.interruptedJoinCallWhileClosingThreadPool(exc, wt, this);

    }

    }

    }

    threadGroup = null;

    }

    实际查看JDK后发现,JDK中其实也没有辣么多的实例,并且大多数直接关联线程状态的,也是一些状态查看的东东。

    这在文章开头就说,Java线程操作,是很底层的,甚至其实现都不包含在虚拟机规范中。

    主流的HotSpot,也是直接将Java线程映射到系统线程,由系统进行一系列的线程调度处理。

    所以,在JDK中,是直接对线程状态进行处理的部分是很少的。

    五、为什么需要线程状态

    1.为什么需要线程状态这一概念

    这个问题,可以从两个角度来说明:生命周期与资源管理

    一方面,线程状态很好地刻画了线程的整个生命周期,对生命周期中不同阶段进行了有效划分。

    另一方面,资源是有限的,需求是无限的。所以需要将系统资源有意识地进行调度,合理利用比较优势,追求帕累托最优。

    实现后者的,就是利用线程在生命周期的不同阶段这一天然属性带来的状态刻画,进行的分组。CPU调度只需要关注运行状态的线程。而阻塞,等待等线程,都有着属于自己的一套处理方式。最终获得资源(开发时对复杂性的应对,运行时对系统资源对消耗,应用者心智模型的成长等)的优化分配。

    2.JDK中为什么需要定义Java线程状态

    前文有说到,Java中很少直接使用到线程状态。那么为什么还要在JDK中定义Java的六种线程状态呢?

    一方面,通过信息透明的方式,降低使用者使用时建立心智模型的成本。如,现在的我们可以通过打印日志,打断点,快速了解Java的各个线程状态,并清楚了解产生的原因。从而大大提高了我们对Java线程的认识,进而更为愉快地拥抱JUC包下诸如线程池等工具。

    另一方面,通过可以直接应用的状态枚举,我们可以很好地对现有工具进行二次开发等。如我们可以通过扩展AQS,并在其中添加线程状态的校验,从而得到定制化的线程同步工具。

    六、如何使用线程状态

    使用的方式,我已经在上文说了:学习Java线程,定制线程相关工具开发。

    这里给出一个有关线程学习的demo:

    /**

    * @program: learning

    * @description: 用于确认线程状态问题

    * @author: Jarry

    * @create: 2020-10-26 22:25

    **/

    public class ThreadState {

    public static void main(String[] args) {

    threadStateTest();

    // threadStateTest2();

    // threadStateWithBlocked();

    // threadStateWithException();

    // threadStateWithSuspend();

    }

    /**

    * 实践证明:Thread.suspend()与Thread.resume()不会改变线程状态

    * 线程状态该是Waiting,就Waiting。该Timed_Waiting就Timed_Waiting

    * Thread.suspend()与Thread.resume()只是挂起目标线程(并且不会释放锁资源)

    */

    private static void threadStateWithSuspend() {

    Thread thread1 = new Thread(() -> {

    // LockSupport.park();

    LockSupport.parkNanos(2000000000);

    });

    thread1.start();

    printThreadState(thread1);

    LockSupport.parkNanos(500000000);

    printThreadState(thread1);

    thread1.suspend();

    printThreadState(thread1);

    LockSupport.parkNanos(500000000);

    printThreadState(thread1);

    thread1.resume();

    LockSupport.parkNanos(500000000);

    printThreadState(thread1);

    // LockSupport.unpark(thread1);

    }

    /**

    * 展现线程阻塞状态

    */

    private static void threadStateWithBlocked() {

    Runnable runnable = new Runnable() {

    @Override

    public void run() {

    synchronized (ThreadState.class) {

    // LockSupport.parkNanos(2000000000);

    LockSupport.park();

    }

    }

    };

    Thread thread1 = new Thread(runnable);

    Thread thread2 = new Thread(runnable);

    thread1.start();

    LockSupport.parkNanos(500000000);

    thread2.start();

    // 加上以下时间间隔,则结果:Runnable->Blocked

    // 推论:Thread.start()会将线程状态设置为Runnable,然后在遇到sync的锁,再切换为Blocked状态

    // LockSupport.parkNanos(500000000);

    printThreadState(thread2);

    LockSupport.parkNanos(500000000);

    printThreadState(thread2);

    LockSupport.parkNanos(500000000);

    LockSupport.unpark(thread1);

    LockSupport.unpark(thread2);

    }

    /**

    * 由于底层实现机制的不同(相较于其他waiting的方法),无法直接进行Object.wait(),否则会抛出以下异常

    * @exception java.lang.IllegalMonitorStateException

    * object.wait()进行wait的方法,是直接对其wait_set进行操作

    */

    private static void threadStateWithException() {

    Thread thread1 = new Thread(() -> {

    try {

    ThreadState.class.wait(2000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    });

    thread1.start();

    LockSupport.parkNanos(1000000000);

    printThreadState(thread1);

    }

    /**

    * Object.wait()的使用

    */

    private static void threadStateTest3() {

    Thread thread1 = new Thread(() -> {

    synchronized (ThreadState.class) {

    try {

    ThreadState.class.wait(2000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    });

    thread1.start();

    LockSupport.parkNanos(1000000000);

    printThreadState(thread1);

    }

    /**

    * 确定LockSupport.parkNacos()是否可以生成Time_Waiting状态

    */

    private static void threadStateTest2() {

    Thread thread1 = new Thread(() -> {

    LockSupport.parkNanos(2000000000);

    });

    thread1.start();

    printThreadState(thread1);

    LockSupport.parkNanos(1000000000);

    printThreadState(thread1);

    }

    /**

    * 查看到除Blocked以外的所有线程状态

    */

    private static void threadStateTest() {

    Thread thread1 = new Thread(() -> {

    synchronized (ThreadState.class) {

    // Runnable

    printThreadState(Thread.currentThread());

    // 1.Thread.sleep(time)

    try {

    Thread.sleep(2000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    // 2.Object.wait(time)

    // try {

    // ThreadState.class.wait(2000);

    // } catch (InterruptedException e) {

    // e.printStackTrace();

    // }

    // 3.Thread.join(time)

    // try {

    // Thread.currentThread().join(2000);

    // } catch (InterruptedException e) {

    // e.printStackTrace();

    // }

    // 4.LockSupport.parkNanos(time);

    // LockSupport.parkNanos(2000000000);

    // 5.LockSupport.parkUntil(timeStamp);

    // LockSupport.parkUntil(System.currentTimeMillis()+2000);

    LockSupport.park();

    }

    });

    thread1.setName("test_thread");

    // New

    printThreadState(thread1);

    thread1.start();

    LockSupport.parkNanos(1000000000);

    // Timed_waiting

    printThreadState(thread1);

    LockSupport.parkNanos(2000000000);

    // Waiting

    printThreadState(thread1);

    LockSupport.unpark(thread1);

    LockSupport.parkNanos(1000000000);

    // Terminated

    printThreadState(thread1);

    }

    private static void printThreadState(Thread thread) {

    System.out.println("current Thread(" + thread.getName()+":" + thread.getId() + ") state:" + thread.getState());

    }

    }

    代码中有一些细碎的知识点,就不在这里赘述了。感兴趣的小伙伴,可以自己看看注释,自行验证。

    七、扩展:系统状态(三态&五态)

    操作系统就包含进程管理,作业管理,文件管理等。其中进程管理,就涉及系统状态的三态模型与五态模型。

    其中,三态模型包含以下三种状态:

    就绪状态

    运行状态

    阻塞状态

    而五态模型则包含以下五种状态:

    运行状态

    静止就绪态

    活跃就绪态

    静止阻塞态

    活跃阻塞态

    具体状态切换等,可以看我之前写的一篇博客:

    系统架构设计师-操作系统

    最后,愿与诸君共进步。

    八、附录

    补充:WAITTING/TIMED_WAITTING与BLOCKED的区别

    其实,我之前也挺纠结这个问题的。

    当时的想法是WAITTING/TIMED_WAITTING是由JVM自己维持,而BLOCKED是由系统维持的。后面看到主流的HotSpot是将线程映射到系统原生线程的,所以这个想法大概率是错误的。

    那么两者区别是什么呢?

    直到我在上文的示例代码中,BLOCKED状态的线程,在其他线程释放其所需的锁时,该线程是先转为RUNNING状态,再变为其他状态。这引起我的注意。

    最后在stackOverFlow的一篇文章(Difference between WAIT and BLOCKED thread states)中,看到这样的解释:

    The important difference between the blocked and wait states is the impact on the scheduler. A thread in a blocked state is contending for a lock; that thread still counts as something the scheduler needs to service, possibly getting factored into the scheduler's decisions about how much time to give running threads (so that it can give the threads blocking on the lock a chance).

    Once a thread is in the wait state the stress it puts on the system is minimized, and the scheduler doesn't have to worry about it. It goes dormant until it receives a notification. Except for the fact that it keeps an OS thread occupied it is entirely out of play.

    This is why using notifyAll is less than ideal, it causes a bunch of threads that were previously happily dormant putting no load on the system to get woken up, where most of them will block until they can acquire the lock, find the condition they are waiting for is not true, and go back to waiting. It would be preferable to notify only those threads that have a chance of making progress.

    (Using ReentrantLock instead of intrinsic locks allows you to have multiple conditions for one lock, so that you can make sure the notified thread is one that's waiting on a particular condition, avoiding the lost-notification bug in the case of a thread getting notified for something it can't act on.)

    简单说,就是CPU时间片不会考虑WAITTING/TIMED_WAITTING状态。

    但是,虽然BLOCKED状态的线程无法获得CPU时间片,但是系统调度时,依旧会考虑BLOCKED状态的线程,将其置于调度计算中。

    如果哪位小伙伴对这方面有了解,希望可以聊一聊。

    参考

    展开全文
  • 线程

    2021-04-02 19:49:31
    线程的基本概念 1.线程的引入 在20世纪90年代后,多处理机系统得到迅速发展,所以提出了比进程更小的、能独立运行的基本单位----线程,以提高系统内程序并发执行的程度...引入线程目的是简化进程间的通信,以小的开销

    线程的基本概念
    1.线程的引入
    在20世纪90年代后,多处理机系统得到迅速发展,所以提出了比进程更小的、能独立运行的基本单位----线程,以提高系统内程序并发执行的程度,改善0S的性能。
    ➢创建进程时,需要为它分配资源,建立PCB;
    ➢撤销进程时,需要回收资源,撤销PCB;
    ➢进程切换时,需要保留当前进程的CPU环境、设置新选中进程的CPU环境,代价较高。
    由于进程在切换时,付出较大的时空开销,所以,在系统中所设置的进程数不宜过多,否则会影响系统的并发程度。
    引入线程的目的是简化进程间的通信,以小的开销来提高进程内的并发程度。
    2.线程与进程的比较
    资源:进程是拥有资源的基本单位,线程只拥有必不可少的资源,如:线程状态、寄存器上下文和栈;
    调度:由于线程基本不拥有资源,切换代价低,所以,线程作为调度和分派的基本单位。
    并发:进程可以并发,一.个进程中的多个线程也可以并发。例如:一个文件服务进程可设置多个线程,当一个线程阻塞时,其它线程仍可提供服务。
    开销:在系统中,线程的切换、同步、通信比进程的代价更低。
    3.线程的属性
    ➢轻型实体。
    ➢独立调度和分派的基本单位。
    ➢可并发执行。
    ➢共享进程资源。
    4.线程的状态
    在操作系统中的每一个线程,都可以利用线程标识符和一组状态参数进行描述。
    (1)状态参数
    ①寄存器状态
    ②堆栈
    ③线程运行状态
    ④优先级
    ⑤线程专有存储器
    ⑥信号屏蔽
    (2)线程运行状态;
    各线程之间也存在着共享资源和相互合作的制约关系,致使线程在运行时也具有间断性。
    ①执行状态
    ②就绪状态
    ③阻塞状态
    由于线程不拥有资源,所以无“挂起状态。
    Windows NT的7种线程状态:
    初始化状态(Initialized):线程创建过程中的线程状态;
    就绪状态(Ready):进程已获得除处理机外的所需资源,等待执行。
    备用状态(Standby):特定处理器的执行对象,系统中每个处理器上只能有一个处于备用状态的线程。
    运行状态(Running):完成描述表切换,线程进入运行状态。
    等待状态(Waiting):线程等待对象句柄,以同步它的执行。
    转换状态(Transition):线程在准备执行而其内核堆栈处于外存时,线程进入转换状态;当其内核堆栈调回内存,线程进入就绪状态。
    终止状态(Terminated):线程执行完就进入终止状态;如执行体有一指向线程对象的指针,可将线程对象重新初始化,并再次使用。
    5.线程的创建和终止
    在多线程0S环境下,应用程序在启动时,通常仅有一个线程在执行,称为“初始化线程”。它可以根据需要再去创建若干个线程。
    终止线程的方式有两种:一种是在线程完成了自己的工作后退出;另一
    种是线程在运行中出现错误、或由于某种原因而被其它线程强行终止。
    6.多线程0S中的进程
    多线程0S中的进程有以下属性:
    (1)作为系统资源分配的单位。
    (2) 可包括多个线程。
    (3)进程不是一个可执行的实体。
    在多线程0S中,进程是作为拥有系统资源的基本单位,通常的进程都包含多个线程并为它们提供资源,此时的进程就不再作为一个执行的实体。
    所谓进程处于执行状态,实际上是该进程中的线程正在执行。
    线程间的同步和通信
    1.互斥锁(mutex)
    在多线程0S中提供多种同步机制。互斥锁是一种比较简单的、用于实现进程间对资源互斥访问的机制。
    互斥锁可以有两种状态,即开锁(unlock)和关锁(lock)状态
    由于操作互斥锁的时间和空间开锁都较低,较适合于高频度使用的关键共享数据和程序段。
    2.条件变量
    许多情况下,只利用mutex实现互斥会引起死锁,所以,引入条件变量;每一个条件变量通常都与一个互斥锁一起使用,亦即,在创建一个互斥锁时便联系着一个条件变量。
    单纯的互斥锁用于短期锁定,主要是用来保证对临界区的互斥进入。
    条件变量则用于线程的长期等待,直至所等待的资源成为可用的。
    内核支持线程和用户级线程
    1.内核支持线程
    系统在内核空间还为每一个内核支持线程设置了一个线程控制块,内 核是根据该控制块而感知某线程的存在的,对其加以控制。
    (1)内核维护线程的切换;
    (2)一个线程发起系统调用而阻塞,不会影响其他线程的运行,CPU会调度其它线程运行。
    内核线程只拥有很少的资源,相对于进程,其切换开销小。但相对于用户级线程,系统开销较大。
    2.用户级线程
    用户级线程仅存在于用户空间中。对于这种线程的创建、撤消、 线程之间的同步与通信等功能,都无须利用系统调用来实现。
    内核不了解用户线程的存在;
    用户线程的维护由应用进程完成;
    用户线程切换不需要内核特权。
    如:进程A包括1个用户级线程,进程B包括100个用户级线程,由于内核不了解用户线程的存在,为进程A、B分配相同的资源,A中线程的运行速度将是B中线程的100倍。
    线程控制
    内核级线程和用户级线程
    不管是内核级线程,还是用户级线程,都必须直接或者间接地取得内核支持。
    1.内核支持线程的实现
    系统创建新线程时,为其分配一个任务数据区PTDA包括若千个线程控制块TCB,每个TCB中可保存线程标识符、优先级、线程运行时间等信息。
    在这里插入图片描述
    内核支持线程的创建、撤消、调度、切换等,与前面讲过的进程方式,十分相似。其开销比进程少得多。
    2.用户级线程的实现
    用户级线程具有相同的结构,由于是存放在用户空间,必须借助于某种形式的中间系统的帮助,方能取得内核服务。
    (1)运行时系统
    是用于管理和控制线程的函数(过程)的集合,其中包括用于创建和撤消线程的函数、线程同步和通信的函数以及实现线程调度的函数等。
    运行时系统中的所有函数都驻留在用户空间,并作为用户级线程与内核之间的接口。
    (2)内核控制线程
    内核控制线程又称轻型进程。
    每一个进程都可拥有多个轻型进程,每个LWP都有自己的数据结构(如TCB)
    LWP可通过系统调用来获得内核提供的服务,当一个用户级线程运行时,只要将它连接到一个LWP上,此时它便具有了内核支持线程的所有属性。
    在这里插入图片描述

    展开全文
  • 什么是线程安全

    2021-03-06 13:28:00
    按照线程安全的“安全程度”由强到弱排序,我们可以将java语言中各种操作共享的数据分为以下五类:不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。 不可变 不可变得对象一定是线程安全的,无论是对象的...
  • 在 MySQL 5.7 处理备库延迟的时候,可以考虑调整这两个参数值,来达到提升备库复制并发度的目的。 undo log 在InnoDB存储引擎层面主要分为两种日志,一种是redo log 一种是undo log。InnoDB支持事物、支持MVCC多版本...
  • ExecutorService是否保证线程安全?我将把来自不同线程的作业提交到同一个ThreadPoolExecutor,在交互/提交任务之前,是否必须同步对执行者的访问?(与其他答案相反)记录了线程安全协定:在interface javadocs中查找...
  • 引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径,因为轻量级锁的获取及释放依赖多次 CAS 原子指令,而偏向锁只需要在置换ThreadID 的时候依赖一次 CAS 原子指令即可。 偏向锁只有遇到...
  • 线程(重点)

    2021-03-02 11:12:46
    线程Java多线程面试问题1. 进程和线程之间有什么不同?一个进程是一个独立(self contained)的运行环境,它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和...
  • Redis为什么选择单线程?②. 既然单线程这么好,为什么逐渐又加入了多线程特性?③. redis6的多线程和IO多路复用入门篇④. Redis6.0默认是否开启了多线程?⑤. 对应REDIS总结语句 ①. Redis为什么选择单线程? ①. ...
  • 进程和线程 1. 进程   操作系统最核心的概念就是进程:它是对正在运行程序的一个抽象,从操作系统角度来看,进程 = 程序 + 数据 + PCB 。 1.1. 进程模型   在进程模型中,计算机上所有可运行的软件,包括操作...
  • 1,什么是线程线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。程序员可以通过它进行多处理器编程,你可以使用多线程对运算密集型任务提速。比如,如果一个线程完成一个...
  • 三、JAVA线程锁机制是怎样的?偏向锁、轻量级锁、重量级锁有什么区别?锁机制是如何升级的? 1、java的锁就是在对象的Markword中记录一个锁状态。无锁、偏向锁、轻量级锁、重量级锁对应不同的锁状态。 2、java的锁...
  • 线程

    2021-05-25 02:44:28
    Java多线程-Lock锁的使用2019-03-15 13:47:55文章目录Lock锁的使用一 Lock接口1.1 Lock接口简介1.2 Lock的简单使用1.3 Lock接口的特性和常见方法二 Lock接口的实现类:ReentrantLock2.1 第一个ReentrantLock程序2.2 ...
  • 线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一。在这里,从面试的角度列出了大部分重要的问题,但是你仍然应该牢固的掌握Java多线程基础知识来对应日后碰到的问题。(校对注:非...
  • C#多线程

    2021-11-18 14:55:44
    1、概念 1.0 线程的和进程的关系以及优缺点 windows系统是一个多线程的操作系统。一个程序至少有一个进程,一个进程至少有一个...C#是一门支持多线程的编程语言,通过Thread类创建子线程引入using System.Threading
  • Java多线程

    2021-07-13 15:52:16
    Java多线程前言进程与线程进程概念线程概念为什么要在代码中引入线程?并发编程及优缺点并发编程的三要素并发、并行、串行的区别线程与进程的区别上下文切换守护线程和用户线程的区别用户态和内核态创建线程的几种...
  • Java 多线程

    2021-03-14 22:17:50
    Java 多线程线程是进程的轻量级最小部分,可以与同一进程的...让我们总结讨论点:多线程主要目的是同时执行程序的两个或多个部分,以最大限度地利用 CPU 时间。多线程程序包含两个或多个可以并发运行的部分。程...
  • 随便谈谈多线程

    2021-08-15 18:46:12
    线程基础 文章目录多线程基础前言一、pandas是什么?二、使用步骤1.引入库2.读入数据总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断...1.引入库 代码如下(示例): import numpy as
  • 并发线程

    2021-04-01 12:15:57
    线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。线程不安全就是不提供数据访问...
  • 线程的本质

    2021-01-13 05:09:05
    线程是万恶之源,这是我的一个基本架构判断。显然这句话很偏颇,但对很多新手来说,记住这句话很重要。很多架构问题,都是线程引起的,本文解剖一下这个问题的核心在哪里。软件通过抽象降低系统熵增速度。比如说,...
  • Java线程模型

    2021-02-12 22:24:09
    Java线程模型本文将从...所以引入线程目的就是为了细化进程对CPU时间占用粒度,更加充分的利用CPU。因为线程是对进程的切片,所以线程是共享进程资源的,同一进程里线程的切换不会影响进程的切换。与进程的区别...
  • Java进程和线程

    2021-03-09 18:12:43
    1. 进程和线程进程:进程表示一个运行的程序,程序的代码段,数据段这些都是存放在磁盘中的,在运行时加载到内存中...在引入线程的操作系统中,通常都是把进程作为分配资源的基本单位,而把线程作为独立运行和独立调...
  • java内存模型与线程

    2021-03-06 07:01:15
    ①主内存和工作内存 Java内存模型的主要目标是定义程序中各个变量的访问规则,即在虚拟机中将变量存储到内存和从内存中取出变量这样底层细节。此处的变量与Java编程时所说的变量不一样,指包括了实例字段、静态字段...
  • 这里都是我从各个地方找来的资料,鸣谢:面试题开始线程和进程有什么区别?答:一个进程是一个独立(self contained)的运行环境,它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。线程是进程的...
  • JAVA多线程并发

    2021-01-15 12:03:48
    文章目录JAVA并发知识结构JAVA线程实现/创建方式继承Thread类实现Runnable接口ExecutorService,Callable,Future有返回值线程基于线程池的方式4种线程池线程生命周期(状态)终止线程4种方式正常运行结束使用退出标志...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 151,493
精华内容 60,597
关键字:

引入线程的主要目的是