进程线程协程

smlie_A

已于 2022-02-08 21:57:13 修改

阅读量156

点赞数

分类专栏： java 文章标签： java

于 2022-02-08 21:05:22 首次发布

本文链接：https://blog.csdn.net/smlie_A/article/details/122826716

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

进程

定义：为了更好利用CPU资源而出现。通过进程分配系统资源，标识任务。进程是系统资源分配到最小单位。

在这里插入图片描述

进程占有的资源：地址空间、全局变量、文件描述、各种硬件资源
调度：分配CPU去执行进程
上下文切换：进程状态的记录、恢复、切换称之为上下文切换

什么是 CPU 上下文
有时也称做进程切换或任务切换，是指CPU从一个进程或线程切换到另一个进程或线程。由CPU 寄存器和程序计数器实现。
1、CPU 寄存器是 CPU 内置的容量小、但速度极快的内存。
2、程序计数器则是用来存储 CPU 正在执行的指令位置、或者即将执行的下一条指令位置。

什么是 CPU 上下文切换
就是先把前一个任务的 CPU 上下文（也就是 CPU 寄存器和程序计数器）保存起来，然后加载新任务的上下文到这些寄存器和程序计数器，最后再跳转到程序计数器所指的新位置，运行新任务。
而这些保存下来的上下文，会存储在系统内核中，并在任务重新调度执行时再次加载进来。这样就能保证任务原来的状态不受影响，让任务看起来还是连续运行

线程

定义：为了降低上下文切换的消耗，提供系统的并发性，并突破一个进程只能干一样事的缺陷，使进程内并发成为可能。线程共享进程的大部分资源，并参与CPU调度，当然线程自己也是拥有自己的资源：栈、寄存器等。

线程的生命周期

1、新建状态: 使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。

2、就绪状态:当线程对象调用了start()方法之后，该线程就进入就绪状态。要等待JVM里线程调度器的调度。

3、运行状态:如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

4、阻塞状态:如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

    等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
    同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
    其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

5、死亡状态: 一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

在这里插入图片描述

常用创建线程的方法

1.实现 Runnable 接口
1.1、定义一个类实现Runnable接口；
1.2、创建该类的实例对象obj；
1.3、将obj作为构造器参数传入Thread类实例对象，这个对象才是真正的线程对象；
1.4、调用线程对象的start()方法启动该线程；

2、继承 Thread 类本身
2.1、定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把run()称为线程的执行体；
2.2、创建该类的实例对象，即创建了线程对象；
2.3、调用线程对象的start()方法来启动线程；

3、通过 Callable 和 Future 创建线程。
以上引自

通过runnable和thread创建进程,案例

public class Test {
    public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
    }
     static class MyThread extends Thread{
        private int ticket = 5;
        public void run(){
            while(true){
                System.out.println("Thread ticket = " + ticket--);
                if(ticket < 0){
                    break;
                }
            }
        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        MyThread2 mt=new MyThread2();
        new Thread(mt).start();
        new Thread(mt).start();
    }
    static class MyThread2 implements Runnable{
        private int ticket = 5;
        public void run(){
            while(true){
                System.out.println("Runnable ticket = " + ticket--);
                if(ticket < 0){
                    break;
                }
            }
        }
    }
}

二者区别：
Thread实现了Runnable接口，提供了更多的可用方法和成员而已。
结论，Thread和Runnable的实质是继承关系，没有可比性。无论使用Runnable还是Thread，都会new Thread，然后执行run方法。
用法上，如果有复杂的线程操作需求，那就选择继承Thread，如果只是简单的执行一个任务，那就实现runnable。

Thread 常用函数

sleep(long millis)

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

yield()

暂停当前正在执行的线程对象，并执行其它线程。
yield()应该做的是,让当前执行线程回到可执行状态，以同意具有同样优先级的其它线程获得执行机会。
因此，使用yield()的目的是让同样优先级的线程之间能适当的轮转执行。可是，实际中无法保证yield()达到让步目的。由于让步的线程还有可能被线程调度程序再次选中。

sleep()和yield()的差别

执行sleep()的线程在指定的时间内肯定不会被执行；
yield()仅仅是使当前线程又一次回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

join()

指等待t线程终止
就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，仅仅有等到子线程结束了才干执行。

为什么要用join()方法？
在非常多情况下，主线程生成并起动了子线程，假设子线程里要进行大量的耗时的运算。主线程往往将于子线程之前结束，可是假设主线程处理完其它的事务后。须要用到子线程的处理结果，也就是主线程须要等待子线程执行完毕之后再结束，这个时候就要用到join()方法了。

setPriority()

更改线程的优先级。

interrupt()

不要以为它是中断某个线程。它仅仅是线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出。从而结束线程，可是假设你吃掉了这个异常，那么这个线程还是不会中断的！

wait()

wait:线程在获取对象锁后，主动释放对象锁，同一时候本线程休眠。直到有其它线程调用对象的notify()唤醒该线程。才干继续获取对象锁。并继续执行。 Obj.wait()与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作。

notify()

对对象锁的唤醒操作。notify()调用后，并非马上就释放对象锁的，而是在对应的synchronized(){}语句块执行结束,自己主动释放锁后。

wait和sleep差别
共同点：

他们都是在多线程的环境下，都能够在程序的调用处堵塞指定的毫秒数。并返回。
wait()和sleep()都能够通过interrupt()方法打断线程的暂停状态，从而使线程立马抛出InterruptedException。

不同点：

Thread类的方法：sleep(),yield()等
Object的方法：wait()和notify()等
每个对象都有一个锁来控制同步訪问。Synchronizedkeyword能够和对象的锁交互，来实现线程的同步。
sleep方法没有释放锁。而wait方法释放了锁，使得其它线程能够使用同步控制块或者方法。

https://www.cnblogs.com/cynchanpin/p/6746844.html

协程

在线程中实现调度（微线程），它的调度不来自于CPU，而是完全来自于用户控制；这样可以避免内核级别的上下文切换造成的性能损失，进而突破在IO上的性能瓶颈。

三者关系：

1、一个进程有多个线程，一个线程有多个协程
2、一个进程可以单独有多个协程
3、线程进程都是同步机制，协程则是异步

进程与线程的区别

进程：每一个进程都有独立的代码和数据空间（进程上下文）。进程间的切换会有较大的开销，一个进程包括1–n个线程。（进程是资源分配的最小单位）

线程：同一类线程共享代码和数据空间，每一个线程有独立的执行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

多进程是指操作系统能同一时候执行多个任务（程序）。

多线程是指在同一程序中有多个顺序流在执行。

举个栗子
开个QQ，开了一个进程；开了迅雷，开了一个进程。在QQ的这个进程里，传输文字开一个线程、传输语音开了一个线程、弹出对话框又开了一个线程。

引自线程和进程的区别是什么？

问题

线程进程的区别

（1）进程

进程是程序的一次执行过程，是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间，至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。

（2）线程

线程是CPU调度和分派的基本单位，它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

（3）联系

线程是进程的一部分，一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

（4）区别：理解它们的差别，我从资源使用的角度出发。（所谓的资源就是计算机里的中央处理器，内存，文件，网络等等）

根本区别：进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位

在开销方面：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

所处环境：在操作系统中能同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行（通过CPU调度，在每个时间片中只有一个线程执行）

内存分配方面：系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源。

包含关系：没有线程的进程可以看做是单线程的，如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程

start和run的区别

1）start() 会创建新的栈空间并且会产生新的子线程(工作线程)

2）run()调用线程对象中的run方法且不会产生新的线程,是在主线程中执行的

smlie_A

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
进程线程协程

目录进程线程线程的生命周期常用创建线程的方法Thread 常用函数sleep(long millis)yield()join()setPriority()interrupt()wait()notify()协程三者关系：进程与线程的区别问题线程进程的区别start和run的区别进程定义：为了更好利用CPU资源而出现。通过进程分配系统资源，标识任务。进程是系统资源分配到最小单位。进程占有的资源：地址空间、全局变量、文件描述、各种硬件资源调度：分配CPU去执行进程上下文切换：进程状态的记录、恢复
复制链接

扫一扫