浅剖Java进程与线程

Posted 2021-05-08 Putarmor

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了浅剖Java进程与线程相关的知识，希望对你有一定的参考价值。

开场白：干就完了

进程与线程

操作系统（OS）
- 一.概念
- 二.定位
进程
线程

操作系统（OS）

一.概念

计算机系统包含基本程序的集合，称为操作系统（OS），我们可以笼统地理解为操作系统包含内核（进程管理、内存管理、文件管理以及驱动管理等）和其他程序（如函数库和shell程序）

二.定位

整个有关计算机软硬件的架构中，操作系统的定位是搞管理的软件，具体怎么理解呢，通过下图可以对OS有个清晰的认知：

1.按照管理者的任务可以分为两类：硬件管理和软件管理
2.按照目标对象分为两种：对内管理和对外业务管理

进程

一.进程是什么？

对于操作系统而言，一个任务就是一个进程（Process）；基于课本中的概念，可以将进程看作一个执行的实例或者一个正在执行的程序；基于内核观点，进程是担当分配资源（CPU时间、内存）的的实体，是操作系统分配资源的最小单位。

二.时间片怎么理解？

现在的操作系统都是支持多任务的，也就是说系统支持同时运行多个任务。操作系统对任务的调度采用“时间片轮转”的调度方式，当一个任务执行一小段时间后强制暂停然后去执行下一个任务，每个任务轮流执行。
任务执行的一小段时间称为时间片；任务正在执行的状态为运行状态；任务执行一段时间后强制暂停后去执行下一个任务，被暂停的任务处于就绪状态等待下一个属于它的时间片的到来。

三.并发与并行的理解

由于任务数量远远超过CPU核心数量，因此操作系统会自动把任务调度到每个核心上执行。

并发：多个进程在一个CPU下采用时间片轮转方式，在一段时间内，让多个进程得以推进，类似“雨露均沾”思想，一个CPU在短时间内会自动调度不同任务。
并行：多个任务在多个CPU分别同时运行，这称之为并行。

操作系统中将并发性与并行性做明显区分，主要从微观角度而言：

并发性：单处理机情况下，多个进程在同一时间间隔运行
并行性：多处理机情况下，多个进程同时运行

举个例子理解并发与并行机制：

客户去银行办理业务

并发性：为了让银行服务人员更好地服务客户，规定每个客户的业务办理时间（防止其他客户长时间等待），银行服务人员将时间片轮转思想应用到客户业务中，当该客户业务的办理时间到达规定时间，银行人员暂停当前业务随之去办理下一个客户的业务，该客户等待下一次时间片的到来。从长时间来看，因为时间片较短，一个银行服务人员被认为可同时服务多个客户，这就可以理解为基于时间片的进程轮转管理机制，就是所谓的并发性。
并行性：银行如果非常有钱，雇佣了很多的工作人员，此时一个客户就会有一个工作人员对接，所有客户的业务真正实现了同时处理，这种机制就称为并行性。

四.内核态与用户态指的什么？

操作系统对执行权限进行分级：内核态和用户态，其中内核态指的是操作系统内核直接控制硬件设备底层软件，权限最高；用户态指的是用户程序权限最低。

五.进程上下文

进程上下文简单来说就是进程在时间片轮转时，需要进行上下文环境切换。这是什么意思呢？

当一个线程正在执行的时候，CPU中保存了寄存器的值、进程的状态以及堆栈上的内容，基于时间片轮转机制切换该进程时，需要保存该进程当前的内容，也就是记录进程的上下文，当再一次执行该进程时，能够恢复到切换时的状态，从而继续正常地执行。

六.进程的状态有哪些？

如下图所示，进程地状态有5个，分别是创建、就绪、运行、阻塞、终止。
在这里插入图片描述

线程

一.线程的认识

1.概念

线程是系统调度资源的最小单位，可认为是“轻量级进程”。

2.线程优点

线程创建时占用更少的资源，进程中的不同线程之间可以共享资源。其中线程可以共享的资源有：①打开的文件 ②共享的内存（如对象 new Object()）。

3.线程与进程的区别是什么？

①进程是操作系统分配资源的最小单位；线程是操作系统调度资源的最小单位。
②进程之间不可以共享资源，而线程之间可以共享资源。
③一个进程中至少包含一个线程（主线程），线程必须依附于进程当中。
④线程是进程执行的最小单位，也是进程执行的实际单位。
⑤进程与线程的区别就像工厂与生产流水线一样，工厂运作的本质是流水线的运行。

二.线程的3类创建方式

1.继承Thread类创建（2种）

第一种：
public class ThreadDemo4 {

    static class MyThread extends Thread {
        @Override
        public void run() {
            // 线程业务
            System.out.println("线程名称：" +
                    Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        // 创建线程对象
        Thread t1 = new MyThread();
        // 启动线程
        t1.start();
        System.out.println("当前线程的名称（主线程）：" +
                Thread.currentThread().getName());

    }
}
===========================================================
第二种：
public class ThreadDemo5 {
    public static void main(String[] args) {

        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("线程名：" +
                        Thread.currentThread().getName());
            }
        };
        thread.start();
    }
}

2.实现Runable接口（3种）

第一种：
public class ThreadDemo6 {
    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("线程名：" +
                    Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        // 1.创建Runnable对象
        MyRunnable runnable = new MyRunnable();
        // 2.创建Thread对象
        Thread thread = new Thread(runnable);
        // 3.启动线程
        thread.start();
    }
}
==========================================================
第二种：
public class ThreadDemo7 {
    public static void main(String[] args) {
        // 匿名内部类的方式实现线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程名：" +
                        Thread.currentThread().getName());
            }
        });
        thread.start();
    }
}
==========================================================
第三种：jdk1.8开始使用
public class ThreadDemo8 {
    public static void main(String[] args) {
        // lambda + 匿名runnable的实现方式
        Thread thread = new Thread(() -> {
            System.out.println("线程名：" +
                    Thread.currentThread().getName());
        });
        thread.start();
    }
}

3.实现Callable接口（1种）

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 前面两类创建线程的方程线，线程业务都没有返回方法，
 * 为了得到线程的执行结果，实现 Callable 接口 + Future 的方式
 */
public class ThreadDemo9 {

    // 创建了线程的任务和返回方法
    static class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            // 生成随机数
            int num = new Random().nextInt(10);
            System.out.println("子线程：" +
                    Thread.currentThread().getName() +
                    ",随机数：" + num);
            return num;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1.创建Callable对象
        MyCallable myCallable = new MyCallable();
        // 2.创建FutrueTask对象接收返回值
        FutureTask<Integer> futureTask =
                new FutureTask<>(myCallable);
        // 3.创建Thread对象
        Thread thread = new Thread(futureTask);
        // 启动线程
        thread.start();
        // 拿到线程执行的结果
        int result = futureTask.get();
        System.out.println(String.format("线程名：%s,数字：%d",
                Thread.currentThread().getName(), result));
    }
}

三.线程的休眠方式

例如：实现主线程休眠1s

1.方式1

Thread.sleep()


public static void main(String[] args) throws InterruptedException {
    System.out.println("开始时间：" + new Date());
    // 休眠1s
    Thread.sleep(1000);  //sleep方法传入的时间以毫秒计算
    System.out.println("结束时间：" + new Date());
}

2.方式2

TimeUnit.SECONDS.sleep(1)


public static void main(String[] args) throws InterruptedException {
    System.out.println("开始时间：" + new Date());
    TimeUnit.SECONDS.sleep(1); // 休眠1s
    System.out.println("结束时间：" + new Date());
}

3.方式3

Thread.sleep(TimeUnit.SECONDS.toMillis())


public static void main(String[] args) throws InterruptedException {
    System.out.println("开始时间：" + new Date());
    Thread.sleep(TimeUnit.SECONDS.toMillis(1)); //休眠1s
    System.out.println("结束时间：" + new Date());
}

4.例题：使用两个线程打印“AABBCCDD”

public static void main(String[] args) {
        // 创建一个任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                String data = "ABCD";
                for (char item : data.toCharArray()) {
                    System.out.print(item);
                    try {
                        // 休眠一段时间
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
    }

程序运行结果：
在这里插入图片描述

四.线程其他

Thread类是Jvm用来管理线程的类，每个线程都有一个唯一的Thread对象与之关联。Thread类的对象就是用来描述一个线程执行流的，Jvm会将这些对象组织起来用于线程调度和线程管理。

1.Thread类常用构造方法

Thread构造方法	构造方法说明
Thread()	无参创建对象
Thread(Runnable target)	使用Runnable对象创建线程对象
Thread(String name)	创建线程对象并命名
Thread(Runnable target, String name)	使用Runnable对象创建线程对象并命名

2.Thread类常用属性

Thread属性	获取方法
线程ID	getId()
线程名称	getName()
线程状态	getState()
优先级	getPriority()
是否后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

在这里插入图片描述
线程优先级补充：

3.线程分类

线程分为守护线程（又叫后台线程）和用户线程（默认线程）

（1）守护线程与用户线程的区别

Java语言中，默认创建的是用户线程。
守护线程是用来为用户线程服务的，当一个程序中的所有用户线程结束之后，无论守护线程是否在工作，守护线程都会随用户线程一起结束。举个例子来说，守护线程的角色就像“服务员”，而用户线程的角色就像“顾客”，当顾客全部走了之后（执行结束），“服务员”就没有了存在的意义，因而整个程序就直接结束运行。
守护线程从业务逻辑层面来看权重比较低，但对于线程调度器来说无论是守护线程还是用户线程，在优先级相同的情况下被执行的概率都是相同的。

（2）如何将线程设置为守护线程？

主线程和默认创建的线程都是用户线程，如下代码所示：

public static void main(String[] args) {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("我是子线程");
        }
    });
    System.out.println("子线程是否为守护线程：" + thread.isDaemon());
        
    //Thread.currentThread()获取当前执行代码的线程对象
    System.out.println("主线程是否为守护线程：" + Thread.currentThread().isDaemon());
}

程序的执行结果：
在这里插入图片描述

从结果可以看出主线程和创建的子线程默认都是用户线程，那么我们想让用户线程变为守护线程如何去做呢？

通过setDaemon(true)将用户线程设置为守护线程，如下面代码所示：

public static void main(String[] args) {
     Thread thread = new Thread(new Runnable() {
         @Override
         public void run() {
             System.out.println("我是子线程");
         }
     });
     // 设置子线程为守护线程
     thread.setDaemon(true);
     System.out.println("子线程是否为守护线程：" + thread.isDaemon());
     System.out.println("主线程是否为守护线程：" + Thread.currentThread().isDaemon());   
}

程序的执行结果：
在这里插入图片描述

从结果可以看出，子线程由默认false变为true，表明子线程被设置为守护线程。

（3）守护线程的注意事项

1）设置守护线程setDaemon(true)必须放在启动线程之前start()，否则程序将报错。
2）在守护线程中创建的线程都是守护线程。
3）使用join()方法时会等待线程执行完，无论是用户线程还是守护线程。

通过代码看一下注意事项：
1）将setDaemon(true)放在start()之后

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                // 打印i信息
                System.out.println("i:" + i + ",isDaemon:" +
                            Thread.currentThread().isDaemon());
                try {
                    // 休眠100毫秒
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             }
         }
     });
     // 启动线程
     thread.start();
     // 设置为守护线程
     thread.setDaemon(true);
}

程序运行结果：
在这里插入图片描述

从结果可以看出，将setDaemon(true)放在start()之后，程序运行报错，此外设置的守护线程也不能生效。

2）守护线程的子线程

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {

                }
            });
            System.out.println("守护线程的子线程是否为守护线程：" +
                        thread2.isDaemon());
       }
   });
   // 设置为守护线程
   thread.setDaemon(true);
   // 启动线程
   thread.start();
   Thread.sleep(<以上是关于浅剖Java进程与线程的主要内容，如果未能解决你的问题，请参考以下文章 
 Java多线程概述及创建
 什么是Java多线程编程？
 多线程编程
 线程学习知识点总结
 java基础入门-多线程同步浅析-以银行转账为样例
 Java进程和线程