线程和进程

最新推荐文章于 2024-07-13 13:55:40 发布

IT牛爷爷

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量811

点赞数 29

分类专栏： Java SE 文章标签： java 大数据线程进程

本文链接：https://blog.csdn.net/weixin_63257947/article/details/140209513

版权

Java SE 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

文章目录

进程和线程
时间片概念
调度方式
线程的创建和启动
线程的名字
线程的优先级
线程状态

进程和线程

进程

在计算机中，进程代表了内存中正在运行的应用程序，计算机中的资源（cpu 内存磁盘网络等），会按照需求分配给每个进程，从而这个进程对应的应用程序就可以使用这些资源了。

在操作系统中，启动一个应用程序的时候，会有一个或多个进程同时被创建，这些进程其实就表示了当前这个应用程序，在系统中的资源使用情况以及程序运行的情况。如果关闭这个进程，那么对应的应用程序也就关闭了。
所以，进程就是在系统中，运行一个应用程序的基本单位。

线程

线程是进程中的一个代码执行单元，负责当前进程中代码程序的执行，一个进程中有一个或多个线程。
当一个进程中启动了多个线程去分别执行代码的时候，这个程序就是多线程程序。

在这里插入图片描述

案例

例如，当前我们去运行一个类的时候，会先启动JVM，这个JVM对于计算机来讲，就是一个
应用程序，所以同时系统中也会启动一个进程和这个JVM对应：

public  class hello{
    public static void main(String[] args)throws Exception{
        System.out.println("hello");
        long time = 1000*100L;
        Thread.sleep(time);
        System.out.println("world");
    }
}

我们运行这个代码：
在这里插入图片描述

注意，代码中，输出hello之后，JVM并没有直接结束，而是让当前线程去休眠了100秒，所以这个时候JVM还在运行着，我们可以在任务管理器中，看到JVM对应的进程了

在这里插入图片描述

除此之外，我们还可以使用JDK中提供的工具，来查看JVM当前的运行情况，在cmd中输入jconsole,然后连接：
在这里插入图片描述

这里通过JDK自带的jconsole工具，可以检测到当前运行Hello这个类的时候，JVM的运行情况，包含内存的使用、线程的运行状态、类的加载等信息.

例如，查看当前JVM中执行main方法线程信:

在这里插入图片描述
(注意，这线程的名字就叫main，它是任务就是调用执行我们类中的main方法,所以，是一个名字叫main的线程，调用执行我们代码中的main方法)

时间片概念

时间片，当前一个线程要使用CPU的时候，CPU会分配给这个线程一小段时间（毫秒级别），这段时间就叫做时间片，也就是该线程允许使用CPU运行的时间，在这个期间，线程拥有CPU的使用权。

如果在一个时间片结束时，线程还在运行，那么这时候，该线程就需要停止运行，并交出CPU的使用
权，然后等待下一个CPU时间片的分配。

（在宏观上，一段时间内，我们感觉两个线程在同时运行代码，其实在微观中，这俩个线程在使用
一个CPU的时候，它们是交替着运行的，每个线程每次都是运行一个很小的时间片，然后就交出CPU使用权，只是它们俩个交替运行的速度太快了，给我们的感觉，好像是它们俩个线程在同时运行。）

调度方式

当俩个或多个线程使用一个CPU来运行代码的时候，在操作系统的内核中，就会有相应的算法来控制线程获取CPU时间片的方式，从而使得这些线程可以按照某种顺序来使用CPU运行代码，这种情况被称为线程调用。

常见的调度方式有两种：

时间片轮转
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
系统会让优先级高的线程优先使用 CPU（提高抢占到的概率），但是如果线程的优先级相同，那么会随机选择一个线程获取当前CPU的时间片。

（JVM中的线程，使用的为抢占式调度。）

线程的创建和启动

java.lang.Thread 是java中的线程类，所有的线程对象都必须是Thread类或其子类的实例。

每个线程的作用，就是完成我们给它指定的任务，实际上就是执行一段我们指定的代码。我们只需要在Thread 类的子类中重写 run 方法，把执行的代码写入到run方法中即可，这就是线程的执行任务

Java中通过继承Thread类来创建并启动一个新的线程的步骤如下：

定义 Thread 类的子类（可以是匿名内部类），并重写 Thread 类中的 run 方法， run 方法中的
代码就是线程的执行任务
创建 Thread 子类的对象，这个对象就代表了一个要独立运行的新线程
调用线程对象的 start 方法来启动该线程

第一种创建方式

package shixun;

public class myTest {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();
    }
}


class MyThread extends Thread{
    @Override
    public void run() {
        int x=0;
        while(true){
            String name = Thread.currentThread().getName();
            System.out.println("hello, ["+name+"] - "+(x++));
            try{
                Thread.sleep(1000);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述

第二种创建方式（匿名内部类）

package shixun;

public class myTest {
    public static void main(String[] args) {
        
       Thread thread=new Thread(){
           @Override
           public void run() {
               int x=0;
               while(true){
                   String name = Thread.currentThread().getName();
                   System.out.println("hello, ["+name+"] - "+(x++));
                   try{
                       Thread.sleep(1000);
                   }catch(Exception e){
                       e.printStackTrace();
                   }
               }
           }
       };

       thread.start();

    }
}

在这里插入图片描述

第三种创建方式（Runnable接口）

package shixun;

public class myTest {
    public static void main(String[] args) {

       Thread thread=new Thread(new Runnable() {
           @Override
           public void run() {
               int x=0;
               while(true){
                   String name = Thread.currentThread().getName();
                   System.out.println("hello, ["+name+"] - "+(x++));
                   try{
                       Thread.sleep(1000);
                   }catch(Exception e){
                       e.printStackTrace();
                   }
               }
           }
       },"线程的名字");  //第二个参数可以指定id
       thread.start();

    }
}

在这里插入图片描述

main线程和t线程之间的关系

在此过程中，main线程和t线程之间的关系是： main线程在执行main方法的过程中，创建并启动了t线程，并且t线程启动后，和main线程就没有关系了，这时候main线程和t线程都是自己独立的运行，并且他们俩个是要争夺CPU的时间片（使用权）的。

线程的名字

通过Thread类中的currentThread方法，可以获取当前线程的对象，然后调用线程对象的getName方法，可以获取当前线程的名字。 String name = Thread.currentThread().getName();

（注意，这里说的当前线程，指的是执行当前方法的线程，因为获取线程名字的代码肯定是写在某个方法中的，并且这个方法一定是由某个线程调用执行的。）
在这里插入图片描述

例如：

package shixun;

public class myTest {
    public static void main(String[] args) {


        String name = Thread.currentThread().getName();
        System.out.println("执行当前main方法的线程是："+name);


        Thread thread=new Thread(new Runnable() {
           @Override
           public void run() {
               String name1 = Thread.currentThread().getName();
               System.out.println("执行当前run方法的线程是："+name1);
           }
       });
       thread.start();

    }
}

在这里插入图片描述
(注意，一定要记得，start方法启动线程后，线程会自动执行run方法,千万不要直接调用run方法，这样就不是启动线程执行任务，而是普通的方法调用。)

默认情况下，主线程中，创建出的线程，它们的都会有一个默认的名字,如Thread-0 Thread-1
Thread-2等等，我们也可以创建线程对象的时候，给它设置一个指定的名字：

Thread t = new Thread("t线程");
//或者
Thread t = new Thread(new Runnable(){
    public void run(){
        //执行任务
   }
},"t线程");
//或者
Thread t = new Thread();
t.setName("t线程");

线程的优先级

线程的优先级使用int类型数字表示，最大是10，最小是1，默认的优先级是5。
当俩个线程争夺CPU时间片的时候：
优先级相同，获得CPU使用权的概率相同
优先级不同，那么高优先级的线程有更高的概率获取到CPU的使用权（只是有更高的概率，并不是一定能获取到）

例如：不设置优先级的情况下，t1和t2线程各自运行10000次循环，看哪个线程先运行完

package shixun;

public class myTest {
    public static void main(String[] args) {

       Thread thread1=new Thread("t1线程"){
           @Override
           public void run() {
               String name = Thread.currentThread().getName();
                    for (int i = 0; i < 10000; i++) {
                    }
                    System.out.println(name+"线程执行完毕");
           }
       };

       Thread thread2=new Thread("t2线程"){
           @Override
           public void run() {
               String name = Thread.currentThread().getName();
               for (int i = 0; i < 10000; i++) {
               }
               System.out.println(name+"线程执行完毕");
           }
       };

        System.out.println("t1线程的优先级："+thread1.getPriority());
        System.out.println("t2线程的优先级："+thread2.getPriority());
        thread1.start();
        thread2.start();



    }
}

在这里插入图片描述
（注意，默认情况下，俩个线程的优先级都是5，那个俩个线程争夺到CPU的使用权的概率一样，那么基本上俩个线程都有相同的概率先执行完10000次循环，其实t1先稍微占了那么一点点的优势，因为毕竟在主线程的代码中，先启动了t1先，然后又启动了t2线程）

然后设置优先级再来运行一下：

在这里插入图片描述

设置完t1和t2优先级之后，在运行结果中会明显看到优先级高的t2线程，会有更高的概率先执行完
代码。

线程状态

线程的状态分为以下几种：

线程状态	描述
NEW（新建）	线程刚被创建，还没调用start方法，或者刚刚调用了start方法，调用 start方法不一定"立即"改变线程状态，中间可能需要一些步骤才完成一个线程的启动。
RUNNABLE(可运行)	start方法调用结束,线程由NEW变成RUNNABLE，线程存活着，并尝试抢占CPU资源，或者已经抢占到CPU资源正在运行，这俩种情况的状态都显示为RUNNABLE
BLOCKED（锁阻塞）	线程A和线程B都要执行方法test，而且方法test被加了锁，线程A先拿到了锁去执行test方法，线程B这时候需要等待线程A把锁释放。这时候线程B就是处理BLOCKED
WAITING（无限期等待）	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入 Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TIMED_WAITING（有限期等待）	和WAITING状态类似，但是有一个时间期限，时间到了，自己也会主动醒来
TERMINATED（终止）	run方法执行结束的线程处于这种状态。

其实 BLOCKED，WAITING，TIMED_WAITING 这三种都属于线程阻塞，只是触发的条件不同，以及从阻塞状态中恢复过来的条件也不同而已。

线程在这三种情况的阻塞下，都具备相同的特点：
1.线程不执行代码
2.线程也不参与CPU时间片的争夺

例如：一个线程，经历的最普通的过程如下：

package shixun;

public class myTest {
    public static void main(String[] args) {

       Thread thread1=new Thread("t1线程"){
           @Override
           public void run() {
               String name = Thread.currentThread().getName();
                    for (int i = 0; i < 100000; i++) {
                    }

           }
       };

       System.out.println(thread1.getState());


      thread1.start();

        System.out.println(thread1.getState());
        System.out.println(thread1.getState());
        System.out.println(thread1.getState());
        System.out.println(thread1.getState());
        System.out.println(thread1.getState());
        System.out.println(thread1.getState());


    }
}

在这里插入图片描述

刚创建好的线程对象，就是出于NEW的状态。
线程启动后，会出于RUNNABLE状态，这个RUNNABLE状态包含俩种情况：
1.就绪状态，此时这个线程没有运行，因为没有抢到CPU的执行权
2.运行状态，此时这个线程正在运行中，因为抢到CPU的执行权

IT牛爷爷

关注

29
点赞
踩
21

收藏

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

在此过程中，main线程和t线程之间的关系是： main线程在执行main方法的过程中，创建并启动了t线程，并且t线程启动后，和main线程就没有关系了，这时候main线程和t线程都是自己独立的运行，并且他们俩个是要争夺CPU的时间片（使用权）的。（注意，默认情况下，俩个线程的优先级都是5，那个俩个线程争夺到CPU的使用权的概率一样，那么基本上俩个线程都有相同的概率先执行完10000次循环，其实t1先稍微占了那么一点点的优势，因为毕竟在主线程的代码中，先启动了t1先，然后又启动了t2线程）
复制链接

扫一扫