精华内容
下载资源
问答
  • 进程线程

    万次阅读 多人点赞 2021-03-17 22:50:20
    进程线程 1 进程 1.1 进程的概念 进程就是正在运行的程序,它代表了程序所占用的内存区域 1.2 进程的特点 独立性 进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,没有...

    进程与线程

    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. 以后如何判断程序有没有线程安全问题?
      在多线程程序中 + 有共享数据 + 多条语句操作共享数据
      解决方案:下一节 同步锁点这里
    展开全文
  • C# 进程退出时 关闭线程

    千次阅读 2018-09-13 10:51:33
    只是关闭当前窗口,若不是主窗体的话,是无法退出程序的,另外若有托管线程(非主线程),也无法干净地退出; Application.Exit(); 强制所有消息中止,退出所有的窗体,但是若有托管线程(非主线程),也无法干净...
    • this.Close();   只是关闭当前窗口,若不是主窗体的话,是无法退出程序的,另外若有托管线程(非主线程),也无法干净地退出;
    • Application.Exit();  强制所有消息中止,退出所有的窗体,但是若有托管线程(非主线程),也无法干净地退出;
    • Application.ExitThread(); 强制中止调用线程上的所有消息,同样面临其它线程法正确退出的问题;
    • System.Environment.Exit(0);   这是最彻底的退出方式,不管什么线程都被强制退出,把程序结束的很干净。

     

    还有1种比较好的方法是把Thread对象的IsBackground属性,设置为true即可,意思就是把线程设置为后台线程。 一个线程或者是后台线程或者是前台线程。后台线程与前台线程类似,区别是后台线程不会阻止进程终止。一旦属于某一进程的所有前台线程都终止,公共语言运行库就会通过对任何仍然处于活动状态的后台线程调用   Abort   来结束该进程。 

    展开全文
  • 父子进程与父子线程退出分析

    千次阅读 2015-08-01 11:40:53
    Linux下编程,线程进程退出顺序问题纷纷扰扰,如果父进程/线程先于子进程/线程终止,系统会做什么处理呢?反之,如果子进程/线程先于父进程/线程终止,系统又会做什么处理呢?下面是我个人平时笔记上做的一些...

    Linux下编程,线程、进程退出顺序问题纷纷扰扰,如果父进程/线程先于子进程/线程终止,系统会做什么处理呢?反之,如果子进程/线程先于父进程/线程终止,系统又会做什么处理呢?下面是我个人平时在笔记上做的一些象征性的总结,如果有疑问之处,大可提出,我一直认为怀疑是人类进步的根本所在。

    一、线程
    Linux线程创建函数为pthread_create(),默认规则是谁创建子线程,谁就要负责子线程的资源回收,当父线程退出后,子线程也随着退出。所以,一般情况下,父线程退出时都要确保子线程已经退出,所以会使用pthread_join()函数阻塞等待子线程的退出信号/标识。
    pthread_detach(threadid)函数的功能是使线程ID为threadid的线程处于分离状态(可以为非父子关系),一旦线程处于分离状态,该线程终止时底层资源立即被回收;否则终止子线程的状态会一直保存占用系统的资源直到主线程调用pthread_join(threadid,NULL)获取线程的退出状态。被创建的子线程也可以自己分离自己,子线程调用pthread_detach(pthread_self())就是分离自己,因为pthread_self()这个函数返回的就是自己本身的线程ID。
    1)父线程先于子线程终止
    父线程先于子线程,则子线程为异常退出 ,那肯定没有使用阻塞非分离函数pthread_join,分2种情况:
    a)子线程已与父线程分离,如调用线程分离函数pthread_detach,则资源被自动回收释放。
    b)子线程未与父线程分离,则资源无法释放,造成了资源浪费和系统臃肿(这种情况,我看有些资料上说系统也能自动释放子线程的资源,如关闭描述符,释放内存空间等等,但个人做过一些测试,比如在子线程中分配很多空间等,进程退出后,top查看内存状态时还存在)。
    2)子线程先于父线程终止
    也分2种情况:
    a)正常情况:子线程调用了线程分离函数ptread_detach(),或父线程调用了等待线程结束函数pthread_join()。
     b)异常情况:如果上面二者都为调用,则为子线程分配的资源无法得到释放。

    二、进程
    一个现有进程可以调用fork函数创建一个新进程。由fork创建的新进程被称为子进程(child process)。fork函数被调用一次但返回两次。两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。
    1)父进程先于子进程终止
    当父进程先退出时,系统会让init进程接管子进程,该子线程成为了孤儿进程。
    2)子进程先于父进程终止
    分为2种情况:
    a)正常情况:父进程调用了wait函数 ( waitpid函数),此时父进程会等待子进程结束。
     b)父进程又没有调用wait函数 ( waitpid函数),此种情况子进程进入僵死状态即僵尸进程,并且会一直保持下去直到系统重启。子进程处于僵死状态时,内核只保存进程的一些必要信息以备父进程所需。此时子进程始终占有着资源,同时也减少了系统可以创建的最大进程数。
    僵死状态:一个已经终止、但是其父进程尚未对其进行善后处理(获取终止子进程的有关信息,释放它仍占有的资源)的进程被称为僵死进程(zombie)。ps命令将僵死进程的状态打印为Z 。

    展开全文
  • 进程(process):是指具有已一定功能的独立程序,是系统资源分配的基本单位,内存中有其完备的数据空间和代码空间,拥有完整的虚拟空间地址。一个进程所拥有的数据和变量只属于它自己。 线程(thread):是进程内...

    线程和进程

    概念

    进程(process):是指具有已一定功能的独立程序,是系统资源分配的基本单位,在内存中有其完备的数据空间和代码空间,拥有完整的虚拟空间地址。一个进程所拥有的数据和变量只属于它自己。

    线程(thread):是进程内相对独立的可执行单元,所以也被称为轻量进程(lightweight processes);是操作系统进行任务调度的基本单元。它与父进程的其它线程共享该进程所拥有的全部代码空间和全局变量,但拥有独立的堆栈(即局部变量对于线程来说是私有的)。

    联系

    进程和线程都具有就绪、阻塞和运行三种基本状态。

    一个进程至少拥有一个线程——主线程,也可以拥有多个线程;一个线程必须且仅有一个父进程。多个进程可以并发执行;一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行。

    支援分配给进程,同一进程的所有线程共享该进程的所有资源

    线程在执行过程中,需要协作同步。不同进程的线程间要利用消息通信的办法实现同步

    处理机分给线程,即真正在处理机上运行的是线程

    线程是指进程内的一个执行单元,也是进程内的可调度实体。

    区别

    进程和线程的主要差别在于它们是不同的操作系统资源管理方式。当然也在系统开销方面有一些体现。

    系统开销:在创建或撤消进程时,由于系统都要为之分配和回收资源,导致系统的开销明显大于创建或撤消线程时的开销

    资源管理:进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,(当一个线程向非法地址读取或者写入,无法确认这个操作是否会影响同一进程中的其它线程,所以只能是整个进程一起崩溃。)所以多进程的程序要比多线程的程序健壮,但在进程切换时,耗费资源较大,效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作,只能用线程,不能用进程。一个进程的开销大约是一个线程开销的30倍左右

    优缺点

    线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源的管理和保护;而进程正相反。同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。

    多进程单线程模型

    master进程管理worker进程:

    • 接收来自外界的信号
    • 向各worker进程发送信号
    • 监控woker进程的运行状态
    • 当woker进程退出后(异常情况下),会自动重新启动新的woker进程

    https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy4yY3RvLmNvbS9zaG91Y2UvTmdpbngvX2ltYWdlcy9jaGFwdGVyLTItMS5QTkc

    这种模型提供了一种保护机制。当其中一个进程内部读取错误,master可以让错误进程重启。这使得你的服务器在表面上并没有感到“曾经崩溃”。

    对于master,完全不涉及服务器的业务,使得错误进程能被安全隔离。

    单进程多线程

    主线程负责监听客户端的连接请求,workers线程负责处理已经建立好的连接的读写等事件


    一旦其中出现一个错误,整个进程都有可能挂掉。你当然可以为此进程编写一个“守护程序”来重启,但是重启期间,你的服务器是真的“挂掉了”。

    展开全文
  • 了解线程进程之间的区别前我们先来认识线程进程,我们从概念入手,什么是线程、什么是进程,再进行进程线程之间的不同点与相同点比较,优点与缺点进行比较理解。 进程的概念 进程(Process)就是程序的一...
  • 线程退出,判断哪些线程退出
  • 为操作系统分配资源的单位是进程,就算main线程退出了,进程还在.资源还在.在进程看来,线程应该都是平级的,没有父子关系. ...如果你希望main线程退出后,所有其他线程也退出.那么你可以把其他线程都设置为守护线程.
  • 工程是使用vs2008编译的,代码中带有详细说明,已经将多余的部分删除,只留有可以编译的源代码,由于提供的只是一种方法,所以示例代码比较精简,你可以使用用于其它应用场景。如有问题或者一些改进意见,麻烦请评论...
  • tcp协议是全双工的,这就可以看成是两条单工信道,单工信道是管道PIPE,对端调用close,对端将发送一个FIN标志给本端,本端进行read返回0的话,就表示对端关闭了对端负责的一条管道,但是本端这一条管道可以...
  • 线程是什么?要理解这个概念,须要先了解一下操作系统的一些相关概念。大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式,也就是说一个任务执行一小段时间强制暂停去执行下一个任务,...
  • Linux下编程,线程进程退出顺序问题纷纷扰扰,如果父进程/线程先于子进程/线程终止,系统会做什么处理呢?反之,如果子进程/线程先于父进程/线程终止,系统又会做什么处理呢?下面是我个人平时笔记上做的一些...
  • Thread TheOpenPrint; TheOpenPrint = new Thread(new ThreadStart(OpenPrin)); TheOpenPrint.IsBackground = true; //申明的地方 ... 进程关闭了 窗体也关了 但是线程还在跑 怎么办
  • 线程进程

    千次阅读 2018-03-01 15:51:03
    作者:pansz链接:...单进程线程:一个人一个桌子上吃菜。2。单进程线程:多个人同一个桌子上一起吃菜。3。多进程单线程:多个人每个人自己的桌子上吃菜。多线程的问题是多个人同时吃一道菜的...
  • linux下,用pthread_create创建线程后线程的默认状态为joinable,如果程序退出线程没被join,则会有线程的资源没有被释放。 调用pthread_join可以,但是程序会再调用该函数阻塞住。 替代的调用pthread_detach...
  • 关于线程进程之间的关系,我觉得有一篇文章讲的很生动形象,这里贴出来供大家参考。进程线程的一个简单解释 关于线程的理解,同样很生动形象的一个例子。我是一个线程 一. 线程进程线程的关系 1....
  • 例子简单了解线程进程

    万次阅读 2020-03-29 16:11:18
    通过例子简单了解下线程进程的概念,更多的的是怎么样去理解这两种东西。
  • 近期工作中,遇到了Python的多线程和守护线程的问题,中间被一篇文章误导了,所以感觉有必要根据查到的资料和自己的实践梳理一下关于python的多进程和多线程问题。 一:基础知识 线程线程是CPU一个基本的...
  • 创建多线程的主进程只要不退出,它(主进程)所创建的所有线程不会被杀死,只是状态均为sleeping状态而已,这样会有一个问题,就是linux系统分配给每个用户所开进程最大数目是有限制的,如果一个进程比如flask或者django....
  • 线程进程的区别

    千次阅读 2013-05-10 20:54:47
    线程进程有 根本的不同。   每个进程 有其独立的 数据空间,文件...线程是多个 函数的并发进行,运行一个独立的进程中,即具有相同的运行环境。 共享全局变量,因此 线程之间的通信 通过更改与读取 全局变量来
  • 线程进程的状态

    千次阅读 2018-04-04 11:18:34
    就绪状态的进程除了CPU之外,其他的运行所需资源都已全部获得。2.1、就绪状态只是说有资格运行,调度程序没有挑选到你,你就永远是可运行状态。2.2、调用线程的start()方法,此线程进入就绪状态。2.3...
  • 线程退出线程资源回收问题

    万次阅读 2017-09-22 00:45:40
    排查发现是由于特殊场景下使子线程异常退出,主线程发现子线程退出便再次创建线程,此时未回收退出线程的资源造成了内存泄漏,导致数据库宿主机oom,此问题不仅导致内存泄漏,会使线程句柄用完导致其他进程无法...
  • //设置为后台进程,这样当主线程退出时,这个线程就会退出                       myThread.Start();//启动线程               }               TY.Net.SocketsT st = new TY.Net....
  • 如何退出线程

    千次阅读 2018-08-07 15:01:15
    之前对于线程如何退出一直不是特别清楚,以前发现用pthread_kill函数退出线程没有... 第一:可以利用pthread_kill函数向线程发信号,而后信号处理函数里面设置一个flag,当线程中检测到该该flag置位后退出死循...
  • 科普帖:线程进程

    千次阅读 多人点赞 2013-09-18 11:24:14
    进程线程:一个人一个桌子上吃菜。单进程线程:多个人同一个桌子上一起吃菜。多进程单线程:多个人每个人自己的桌子上吃菜。 多线程的问题是多个人同时吃一道菜的时候容易发生争抢,例如两个人同时夹一...
  • 线程进程的区别;进程线程、任务的区别? 网上查了查 (1) 进程线程的区别,(2)进程线程、任务的区别: (1) 进程线程的区别 进程线程都是由操作系统所...线程在执行过程中与进程还是有区别的。每
  • Linux线程编程 - 线程退出与等待

    千次阅读 2016-08-26 14:42:28
    线程退出 新创建的线程从执行用户定义的函数处开始执行,直到出现...创建线程进程退出或者整个函数结束。其中的一个线程执行了exec类函数执行新的进程。 等待线程 退出线程示例 [cpp] view plai
  • Python多线程004之守护进程/守护线程

    千次阅读 2018-04-08 11:27:36
    # 只要主线程执行完毕,那么不管子线程是否结束,都会退出,它会等待非守护线程结束才退出 #只要主线程死了,那么守护线程一定死了 def run(n): print('task ',n) time.sleep(2) print('task done',n,threading....
  • 进程线程区别

    千次阅读 2020-08-28 22:20:29
    请描述进程和线程的区别? 进程是程序的一次执行。线程可以理解为进程中执行的一段程序片。...线程是属于进程,当进程退出时该进程所产生的线程都会被强制退出并清除。线程占用的资源要少于进程所占的资源。
  • 进程线程

    万次阅读 2017-12-05 08:11:08
    进程线程 ...进程 ...进程生命周期 ...线程 ...默认情况下,同一应用的所有组件相同的进程线程(称为“主”线程)中运行。 如果某个应用组件启动且该应用已存在进程(因为存在该应用的其他组件)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 207,097
精华内容 82,838
关键字:

线程在进程退出后还在