精华内容
下载资源
问答
  • 进程(process)和线程(thread)是操作系统的基本概念,但是...vs 线程 :一个进程可以包含多个线程" title="进程 vs 线程 :一个进程可以包含多个线程" style="margin:0px; padding:0px; border:0px; list-st

    进程(process)和线程(thread)是操作系统的基本概念,但是它们比较抽象,不容易掌握。

    最近,我读到一篇材料,发现有一个很好的类比,可以把它们解释地清晰易懂。

    1.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    计算机的核心是CPU,它承担了所有的计算任务。它就像一座工厂,时刻在运行。

    2.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    假定工厂的电力有限,一次只能供给一个车间使用。也就是说,一个车间开工的时候,其他车间都必须停工。背后的含义就是,单个CPU一次只能运行一个任务。

    3.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    进程就好比工厂的车间,它代表CPU所能处理的单个任务。任一时刻,CPU总是运行一个进程,其他进程处于非运行状态。

    4.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    一个车间里,可以有很多工人。他们协同完成一个任务。

    5.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    线程就好比车间里的工人。一个进程可以包括多个线程。

    6.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    车间的空间是工人们共享的,比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的,每个线程都可以使用这些共享内存。

    7.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    可是,每间房间的大小不同,有些房间最多只能容纳一个人,比如厕所。里面有人的时候,其他人就不能进去了。这代表一个线程使用某些共享内存时,其他线程必须等它结束,才能使用这一块内存。

    8.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    一个防止他人进入的简单方法,就是门口加一把锁。先到的人锁上门,后到的人看到上锁,就在门口排队,等锁打开再进去。这就叫"互斥锁"(Mutual exclusion,缩写 Mutex),防止多个线程同时读写某一块内存区域。

    9.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    还有些房间,可以同时容纳n个人,比如厨房。也就是说,如果人数大于n,多出来的人只能在外面等着。这好比某些内存区域,只能供给固定数目的线程使用。

    10.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    这时的解决方法,就是在门口挂n把钥匙。进去的人就取一把钥匙,出来时再把钥匙挂回原处。后到的人发现钥匙架空了,就知道必须在门口排队等着了。这种做法叫做"信号量"(Semaphore),用来保证多个线程不会互相冲突。

    不难看出,mutex是semaphore的一种特殊情况(n=1时)。也就是说,完全可以用后者替代前者。但是,因为mutex较为简单,且效率高,所以在必须保证资源独占的情况下,还是采用这种设计。

    11.

    进程 <wbr>vs <wbr>线程 <wbr>:一个进程可以包含多个线程

    操作系统的设计,因此可以归结为三点:

    (1)以多进程形式,允许多个任务同时运行;

    (2)以多线程形式,允许单个任务分成不同的部分运行;

    (3)提供协调机制,一方面防止进程之间和线程之间产生冲突,另一方面允许进程之间和线程之间共享资源。

    (完)

    文档信息
    展开全文
  • 进程线程

    万次阅读 多人点赞 2021-03-17 22:50:20
    进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间 动态性 进程与程序的区别在于,程序只是...

    进程与线程

    1 进程

    1.1 进程的概念

    进程就是正在运行的程序,它会占用对应的内存区域,由CPU进行执行与计算。

    1.2 进程的特点

    • 独立性
      进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间
    • 动态性
      进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的.
    • 并发性
      多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响.

    2 线程

    2.1 线程的概念

    线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位.
    一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程。
    我们看到的进程的切换,切换的也是不同进程的主线程
    多线程可以让同一个进程同时并发处理多个任务,相当于扩展了进程的功能。

    2.2 进程与线程的关系

    一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)
    进程与线程的关系
    每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间.
    所以想使用线程技术,得先有进程,进程的创建是OS操作系统来创建的,一般都是C或者C++完成
    进程与线程的关系

    3 多线程的特性

    3.1 随机性

    我们宏观上觉得多个进程是同时运行的,但实际的微观层面上,一个CPU【单核】只能执行一个进程中的一个线程。
    那为什么看起来像是多个进程同时执行呢?
    是因为CPU以纳秒级别甚至是更快的速度高效切换着,超过了人的反应速度,这使得各个进程从看起来是同时进行的,也就是说,宏观层面上,所有的进程看似并行【同时运行】,但是微观层面上是串行的【同一时刻,一个CPU只能处理一件事】。
    线程切换

    串行与并行

    串行是指同一时刻一个CPU只能处理一件事,类似于单车道
    并行是指同一时刻多个CPU可以处理多件事,类似于多车道
    在这里插入图片描述
    在这里插入图片描述

    3.2 CPU分时调度

    时间片,即CPU分配给各个线程的一个时间段,称作它的时间片,即该线程被允许运行的时间,如果在时间片用完时线程还在执行,那CPU将被剥夺并分配给另一个线程,将当前线程挂起,如果线程在时间片用完之前阻塞或结束,则CPU当即进行切换,从而避免CPU资源浪费,当再次切换到之前挂起的线程,恢复现场,继续执行。
    注意:我们无法控制OS选择执行哪些线程,OS底层有自己规则,如:

    1. FCFS(First Come First Service 先来先服务算法)
    2. SJS(Short Job Service短服务算法)

    CPU分片

    3.3 线程的状态

    由于线程状态比较复杂,我们由易到难,先学习线程的三种基础状态及其转换,简称”三态模型” :

    • 就绪(可运行)状态:线程已经准备好运行,只要获得CPU,就可立即执行
    • 执行(运行)状态:线程已经获得CPU,其程序正在运行的状态
    • 阻塞状态:正在运行的线程由于某些事件(I/O请求等)暂时无法执行的状态,即线程执行阻塞
      线程的3种状态

    就绪 → 执行:为就绪线程分配CPU即可变为执行状态"
    执行 → 就绪:正在执行的线程由于时间片用完被剥夺CPU暂停执行,就变为就绪状态
    执行 → 阻塞:由于发生某事件,使正在执行的线程受阻,无法执行,则由执行变为阻塞
    (例如线程正在访问临界资源,而资源正在被其他线程访问)
    反之,如果获得了之前需要的资源,则由阻塞变为就绪状态,等待分配CPU再次执行

    我们可以再添加两种状态:

    • 创建状态:线程的创建比较复杂,需要先申请PCB,然后为该线程运行分配必须的资源,并将该线程转为就绪状态插入到就绪队列中
    • 终止状态:等待OS进行善后处理,最后将PCB清零,并将PCB返回给系统
      线程的5种状态

    PCB(Process Control Block):为了保证参与并发执行的每个线程都能独立运行,OS配置了特有的数据结构PCB来描述线程的基本情况和活动过程,进而控制和管理线程

    3.4 线程状态与代码对照

    线程状态与代码对照
    线程生命周期,主要有五种状态:

    1. 新建状态(New) : 当线程对象创建后就进入了新建状态.如:Thread t = new MyThread();
    2. 就绪状态(Runnable):当调用线程对象的start()方法,线程即为进入就绪状态.
      处于就绪(可运行)状态的线程,只是说明线程已经做好准备,随时等待CPU调度执行,并不是执行了t.start()此线程立即就会执行
    3. 运行状态(Running):当CPU调度了处于就绪状态的线程时,此线程才是真正的执行,即进入到运行状态
      就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态状态执行,先得处于就绪状态
    4. 阻塞状态(Blocked):处于运状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入就绪状态才有机会被CPU选中再次执行.
      根据阻塞状态产生的原因不同,阻塞状态又可以细分成三种:
      等待阻塞:运行状态中的线程执行wait()方法,本线程进入到等待阻塞状态
      同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程占用),它会进入同步阻塞状态
      其他阻塞:调用线程的sleep()或者join()或发出了I/O请求时,线程会进入到阻塞状态.当sleep()状态超时.join()等待线程终止或者超时或者I/O处理完毕时线程重新转入就绪状态
    5. 死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期

    4 多线程代码创建方式1:继承Thread

    4.1 概述

    Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例
    启动线程的唯一方法就是通过Thread类的start()实例方法
    start()方法是一native方法,它将通知底层操作系统,.最终由操作系统启动一个新线程,操作系统将执行run()
    这种方式实现的多线程很简单,通过自己的类直接extends Thread,并重写run()方法,就可以自动启动新线程并执行自己定义的run()方法
    模拟开启多个线程,每个线程调用run()方法.

    4.2 常用方法

    构造方法

    Thread() 分配新的Thread对象
    Thread(String name) 分配新的Thread对象
    Thread(Runnable target) 分配新的Thread对象
    Thread(Runnable target,String name) 分配新的Thread对象

    普通方法

    static Thread currentThread( )
    返回对当前正在执行的线程对象的引用
    long getId()
    返回该线程的标识
    String getName()
    返回该线程的名称
    void run()
    如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法
    static void sleep(long millions)
    在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
    void start()
    使该线程开始执行:Java虚拟机调用该线程的run()

    4.3 测试多线程的创建方式1

    创建包: cn.tedu.thread
    创建类: TestThread1.java

    package cn.tedu.thread;
    /*本类用于多线程编程实现方案一:继承Thread类来完成*/
    public class TestThread1 {
        public static void main(String[] args) {
            //4.创建线程对象进行测试
            /*4.new对应的是线程的新建状态
            * 5.要想模拟多线程,至少得启动2个线程,如果只启动1个,是单线程程序*/
            MyThread t1 = new MyThread();
            MyThread t2 = new MyThread();
            MyThread t3 = new MyThread();
            MyThread t4 = new MyThread();
            /*6.这个run()如果直接这样调用,是没有多线程抢占执行的效果的
            * 只是把这两句话看作普通方法的调用,谁先写,就先执行谁*/
            //t1.run();
            //t2.run();
            /*7.start()对应的状态就是就绪状态,会把刚刚新建好的线程加入到就绪队列之中
            * 至于什么时候执行,就是多线程执行的效果,需要等待OS选中分配CPU
            * 8.执行的时候start()底层会自动调用我们重写的run()种的业务
            * 9.线程的执行具有随机性,也就是说t1-t4具体怎么执行
            * 取决于CPU的调度时间片的分配,我们是决定不了的*/
            t1.start();//以多线程的方式启动线程1,将当前线程变为就绪状态
            t2.start();//以多线程的方式启动线程2,将当前线程变为就绪状态
            t3.start();//以多线程的方式启动线程3,将当前线程变为就绪状态
            t4.start();//以多线程的方式启动线程4,将当前线程变为就绪状态
        }
    }
    
    //1.自定义一个多线程类,然后让这个类继承Thread
    class MyThread extends Thread{
        /*1.多线程编程实现的方案1:通过继承Thread类并重写run()来完成的 */
        //2.重写run(),run()里是我们自己的业务
        @Override
        public void run() {
            /*2.super.run()表示的是调用父类的业务,我们现在要用自己的业务,所以注释掉*/
            //super.run();
            //3.完成业务:打印10次当前正在执行的线程的名称
            for (int i = 0; i < 10; i++) {
                /*3.getName()表示可以获取当前正在执行的线程名称
                * 由于本类继承了Thread类,所以可以直接使用这个方法*/
                System.out.println(i+"="+getName());
            }
        }
    }
    

    5 多线程代码创建方式2:实现Runnable接口

    5.1 概述

    如果自己的类已经extends另一个类,就无法多继承,此时,可以实现一个Runnable接口

    5.2 常用方法

    void run()使用实现接口Runnable的对象创建线程时,启动该线程将导致在独立执行的线程中调用对象的run()方法

    5.3 练习2:测试多线程的创建方式2

    创建包: cn.tedu.thread
    创建类: Thread2.java

    package cn.tedu.thread;
    /*本类用于多线程编程实现方案二:实现Runnable接口来完成*/
    public class TestThread2 {
        public static void main(String[] args) {
            //5.创建自定义类的对象--目标业务类对象
            MyRunnable target = new MyRunnable();
            //6.如何启动线程?自己没有,需要与Thread建立关系
            Thread t1 = new Thread(target);
            Thread t2 = new Thread(target);
            Thread t3 = new Thread(target);
            Thread t4 = new Thread(target);
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }
    
    //1.自定义多线程类
    class MyRunnable implements Runnable{
        //2.添加父接口中的抽象方法run(),里面是自己的业务
        @Override
        public void run() {
            //3.写业务,打印10次当前正在执行的线程名称
            for (int i = 0; i < 10; i++) {
                /*问题:自定义类与父接口Runnable中都没有获取名字的方法
                * 所以还需要从Thread中找:
                * currentThread():静态方法,获取当前正在执行的线程对象
                * getName():获取当前线程的名称*/
                System.out.println(i+"="+Thread.currentThread().getName());
            }
        }
    }
    

    5.4 两种实现方式的比较

    • 继承Thread类
      优点: 编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程
      缺点: 自定义的线程类已继承了Thread类,所以后续无法再继承其他的类
    • 实现Runnable接口
      优点: 自定义的线程类只是实现了Runnable接口或Callable接口,后续还可以继承其他类,在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码、还有数据分开(解耦),形成清晰的模型,较好地体现了面向对象的思想
      缺点: 编程稍微复杂,如想访问当前线程,则需使用Thread.currentThread()方法

    6 售票案例

    需求:设计4个售票窗口,总计售票100张。用多线程的程序设计并写出代码

    6.1 方案1:继承Thread

    创建包: cn.tedu.tickets
    创建类: TestThread.java

    package cn.tedu.tickets;
    /*需求:设计多线程编程模型,4个窗口共计售票100张
    * 本方案使用多线程编程方案1,继承Thread类的方式来完成*/
    public class TestThread {
        public static void main(String[] args) {
            //5.创建多个线程对象
            TicketThread t1 = new TicketThread();
            TicketThread t2 = new TicketThread();
            TicketThread t3 = new TicketThread();
            TicketThread t4 = new TicketThread();
            //6.以多线程的方式启动
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }
    
    //1.自定义多线程售票类,继承Thread
    class TicketThread extends Thread{
        //3.定义变量,保存要售卖的票数
        /*问题:4个线程对象共计售票400张,原因是创建了4次对象,各自操作各自的成员变量
        * 解决:让所有对象共享同一个数据,票数需要设置为静态*/
        static int tickets = 100;
        //2.重写父类的run(),里面是我们的业务
        @Override
        public void run() {
            //4.1循环卖票
            while(true){
                try {
                    //7.让每个线程经历休眠,增加线程状态切换的频率与出错的概率
                    //问题1:产生了重卖的现象:同一张票卖了多个人
                    //问题2:产生了超卖的现象:超出了规定的票数100,出现了0 -1 -2这样的票
                    Thread.sleep(10);//让当前线程休眠10ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //4.2打印当前正在卖票的线程名称,并且票数-1
                System.out.println(getName()+"="+tickets--);
                //4.3做判断,如果没有票了,就退出死循环
                if(tickets <= 0) break;//注意,死循环一定要设置出口
            }
        }
    }
    

    6.2 方案2:实现Runnable

    创建包: cn.tedu.tickets
    创建类: TestRunnable.java

    package cn.tedu.tickets;
    /*需求:设计多线程编程模型,4个窗口共计售票100张
     * 本方案使用多线程编程方案2,实现Runnable接口的方式来完成*/
    public class TestRunnable {
        public static void main(String[] args) {
            //5.创建Runnable接口的实现类对象,作为目标业务对象
            TicketRunnable target = new TicketRunnable();
            //6.创建多个Thread类线程对象,并将target业务对象交给多个线程对象来处理
            Thread t1 = new Thread(target);
            Thread t2 = new Thread(target);
            Thread t3 = new Thread(target);
            Thread t4 = new Thread(target);
            //7.以多线程的方式启动多个线程对象
            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
    }
    
    //1.自定义多线程类实现Runnable接口
    class TicketRunnable implements Runnable{
        //3.定义一个成员变量,用来保存票数100
        /*由于自定义类对象只创建了一次,所以票数被所有线程对象Thread类的对象共享*/
        int tickets = 100;
        //2.添加接口中未实现的方法,方法里是我们的业务
        @Override
        public void run() {
            //4.1循环卖票
            while(true){
                //8.让线程休眠10ms,增加线程状态切换的概率和出错的概率
                try {
                    Thread.sleep(10);//让当前线程休眠10ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //4.2打印当前正在售票的线程名称 & 票数-1
                System.out.println(Thread.currentThread().getName()+"="+tickets--);
                //4.3设置死循环的出口,没票了就停止卖票
                if(tickets <=0 ) break;
            }
        }
    }
    

    6.3 问题

    1. 每次创建线程对象,都会生成一个tickets变量值是100,创建4次对象就生成了400张票了。不符合需求,怎么解决呢?能不能把tickets变量在每个对象间共享,就保证多少个对象都是卖这100张票。
      解决方案: 用静态修饰
    2. 产生超卖,0 张 、-1张、-2张。
    3. 产生重卖,同一张票卖给多人。
    4. 多线程安全问题是如何出现的?常见情况是由于线程的随机性+访问延迟。
    5. 以后如何判断程序有没有线程安全问题?
      在多线程程序中 + 有共享数据 + 多条语句操作共享数据
      解决方案:下一节 同步锁点这里
    展开全文
  • 一个进程最多能包含多少线程

    万次阅读 2012-10-20 16:22:34
    实验蛮简单的,但是,我不由想到了,一个进程最多能包含多少个线程。 在网上查了查,貌似也没找到多少这方面的资料。大部分都是关于服务器多线程链接sever的,关于本机可执行exe的进程数倒是没有什么涉及。 我觉得...

      //小watch水平有限,希望大家多多指正文中的错误,共同进步大笑

    最近在学习os的多线程课程,第一个实验室关于windows的多线程,用mfc实现。实验蛮简单的,但是,我不由想到了,一个进程最多能包含多少个线程。

    在网上查了查,貌似也没找到多少这方面的资料。大部分都是关于服务器多线程链接sever的,关于本机可执行exe的进程数倒是没有什么涉及。

    我觉得唯一一个有用的出处:http://bbs.pediy.com/archive/index.php?t-26541.html

       中间有一句:个人认为是这样的:每个进程是有4G的内存空间,其种只有一部分是给用户使用的,其余是内核使用的,具体多少跟操作系统有关。进程中的所有线程公用这一空间。每个线程又自己的堆栈,再win2k下,如果用VC写程序的话,你能使用的地址空间约为2G,,线程的默认堆栈是1M,可以在编译程序时修改。因此可以推算一个进程的线程数也就两千多个。

    机器配置:虚拟机 +xp  +1G内存

    废话不多说,直接上图。

    主要用一个全局变量 i 标识下,并在i%1000 == 0,时,用getchar()中断下。

    出来的结果并不是我想像中的那样子。

    可以看到pid变得非常非常大,这也让我的机器变得特别卡,这个原因可能就是之前的程序中,创建的线程对应的句柄被大量占用,但却没有被释放。

     

    但是,这和我想要的结果相差很多,再检查,发现线程是void,执行完io操作后,直接就退出挂起了。于是改动如下:

    ok,这下应该差不多了。。执行

    然后到这里,我的虚拟机完全卡住了~~   ⊙﹏⊙b汗

    再等一会。。

     

    直接不响应了!!

    好吧,到这边,基本上,可以总结下了。

    1.进程中,线程的代码执行完直到返回,线程的生命周期基本就算结束了,之后不会占用cpu。但是如果用于标识的线程句柄不释放的话,那么之后执行其它进程时分配的pid就会特别大,计算机也会变得特别卡。

    2.结合网上的资料,可以得出一个结论。进程包含多少线程,其实并不能用个数来衡量,而是取决于电脑的配置。而之前引用中那位说的,线程的默认堆栈是1M,可以在编译程序时修改。所以,所有的线程创建失败提示或是线程最多数,其实都是基于os(operating system)操作系统软件的认为设置或设定的。所以最终决定一个进程最多包含多少线程的因素,其实还是硬件的支持度,一切软件(包括os)的设定都基于,在保证自己运行的基础上,提供内存给进程和线程,而在内存的使用层面,进程和线程其实是一个水平线上的。

    by--secondwatch 转载请注明出处
    展开全文
  • 默认情况下linux环境下一个进程最多能有多少个线程?: 主线程+自己的线程382 = 383 这我自己已经验证过,测试程序在后面。

    默认情况下linux环境下一个进程最多能有多少个线程?:

    主线程+自己的线程382 = 383

    这我自己已经验证过,测试程序在后面。

     

    据说可以设置线程数目:

    据说是可以设置的,但本人还没有验证!不知道可否。

    下面是测试程序,可以验证,在默认情况下一个进程同时最多可以存在的线程数目。

    #include <stdio.h>
    #include <pthread.h>

    void* foo(void* x)
    {

    }

    int main()
     {
             int i = 0;
             pthread_t thread;

             while (1) {
                 if (pthread_create(&thread, NULL, foo, NULL) != 0)
                     return 1;
                 i ++;
                 printf("i = %d\n", i);
              }

            return 0;
     }

     

    展开全文
  • 一个进程能运行多少线程

    千次阅读 2019-04-11 15:22:41
    对于Linux来说: 我们都知道进程的概念,它是CPU分配资源的载体,是程序运行的实例;也知道线程的概念,它是...(一个cpu内核只能运行一个进程/线程,一台8核cpu的服务器只能同时运行8个进程/线程。只是每个进...
  • 如何查询一个进程下面的线程数(进程线程区别) https://www.cnblogs.com/kevingrace/p/5252919.html在平时工作中,经常会听到应用程序的进程线程的概念,那么它们两个之间究竟有什么关系或不同呢?一、对比...
  • 假定工厂的电力有限,一次只能供给一个车间使用,也就是说,一个车间开工的时候,其他车间都必须停工,背后的含义就是,单个CPU一次只能执行一个任务。 进程就好比工厂里的车间,他代表CPU所能处理的单个任务。...
  • 进程线程一个简单解释

    千次阅读 2017-04-07 15:10:50
    进程(process)和线程(thread)是操作系统的基本概念,但是它们比较抽象,不容易...假定工厂的电力有限,一次只能供给一个车间使用。也就是说,一个车间开工的时候,其他车间都必须停工。背后的含义就是,单个CPU一次
  • 进程(process)和线程(thread)是操作系统的基本概念,但是它们比较抽象,不容易掌握。 最近,我读到一篇材料,...假定工厂的电力有限,一次只能供给一个车间使用。也就是说,一个车间开工的时候,其他车间都必须停工。
  • android线程管理进程线程

    千次阅读 2017-07-15 12:09:09
     如果某个应用程序组件是第一次被启动,且这时应用程序也没有其他组件在运行,则Android系统会为应用程序创建一个包含单个线程的linux进程。默认情况下,同一个应用程序的所有组件都运行在同一个进程线程里(这个...
  • 进程线程的区别:一个简单又困难的问题

    千次阅读 多人点赞 2020-04-20 02:45:39
    文章目录进程线程的区别:一个简单又困难的问题进程执是什么线程是什么进程线程的区别 进程线程的区别:一个简单又困难的问题 如果简单得记得,进程是操作系统分配资源的最小单位,线程是CPU调度的最小单位。...
  • 进程线程

    2016-03-29 10:02:07
    线程进程一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的...
  • 进程线程一个简单形象的解释

    千次阅读 2014-07-28 21:53:04
    转眼暑假一过,2015年的校招即将开启大幕,身为计算机专业的朋友们,在面试中是不是经常会被问到一个问题:进程线程的区别,今日偶然看到阮一峰的博客,他用一个很好的类比把他们解释的清晰易懂,会不会突然让大家...
  • 进程线程的深入理解

    万次阅读 多人点赞 2019-04-25 00:14:40
    进程线程的深入理解精确概括进程线程的区别 ...2.假定工厂的电力有限,一次只能供给一个车间使用。也就是说,一个车间开工的时候,其他车间都必须停工。背后的含义就是,单个CPU一次只能运行一个任务。 3...
  • 进程(process)和线程(thread)是操作系统的基本概念,但是...最近,我读到一篇材料,发现有一个很好的类比,可以把它们解释地清晰易懂。 1. 计算机的核心是CPU,它承担了所有的计算任务。它就像一座
  • 一个进程包括由操作系统分配的内存空间,包含一个或多个线程一个线程不能独立的存在,它必须是进程的一部分。一个进程一直运行,直到所有的非守护线程都结束运行后才能结束。 线程  又称其为轻量级进程...
  • 线程进程

    千次阅读 2016-08-07 12:45:41
    线程进程中执行运算的最小单位,是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源...
  • 线程进程

    千次阅读 2017-09-02 18:51:36
    线程进程一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 242,960
精华内容 97,184
关键字:

一个进程只能包含一个线程吗