浅剖Java进程与线程

最新推荐文章于 2021-07-23 20:03:09 发布

Putarmor

最新推荐文章于 2021-07-23 20:03:09 发布

阅读量3.6k

点赞数 23

分类专栏： java 坚持学习 web 文章标签：多线程

本文链接：https://blog.csdn.net/weixin_44874269/article/details/116405054

版权

java 同时被 3 个专栏收录

126 篇文章 5 订阅

订阅专栏

web

26 篇文章 0 订阅

订阅专栏

坚持学习

4 篇文章 0 订阅

订阅专栏

前进前进…

进程与线程

操作系统（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.实现Runnable接口（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()


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(1000);
}

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

从结果可以看出，守护线程中创建的子线程默认也是守护线程。

3）使用join()方法等待守护线程执行结束

默认情况下，程序运行结束不会等待守护线程执行完，当调用线程的等待方法join()时，程序会等待守护线程执行结束后再结束。

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);
                    try {
                        // 休眠 100 毫秒
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        // 设置为守护线程
        thread.setDaemon(true);
        // 启动线程
        thread.start();
        // 等待线程执行完
        thread.join();
        System.out.println("子线程是否为守护线程：" + thread.isDaemon());
        System.out.println("主线程是否为守护线程：" + Thread.currentThread().isDaemon());
    }

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

从结果我们可以看出，守护线程调用等待方法join()，程序会等待守护线程将任务执行结束后结束进程。

（4）守护线程的使用场景

守护线程的经典使用场景是垃圾回收线程；守护线程中创建的线程默认情况下也是守护线程。

五.面试题：start()和run()的区别

Java中通过实例化Thread类产生线程对象，线程对象调用start()启动线程，Thread还有一个run方法貌似也能启动线程，两者的区别到底是什么？

start()：产生线程对象后，调用start()方法启动线程，线程处于运行状态RUNNABLE中的Ready就绪状态中，此时线程等待被CPU调度，调度后再执行run()方法。使用start()方法启动线程，真正意义上实现了多线程。
run()：run()方法是Thread中一个普通方法，当只存在一个创建的线程对象时，用线程对象调用run()方法，程序被主线程main执行。当程序中有两个新建线程时，调用run()方法，程序会按照顺序执行，没有实现多线程并发。

public static void main(String[] args) {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    },"unstoppbale_t");
    t1.start();
}

程序运行结果：

可以看出，调用start()方法启动线程，线程名是子线程名。

public static void main(String[] args) {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    },"unstoppbale_t");
    t1.run();
}

程序运行结果：

可以看出，调用start()方法启动线程，线程名是主线程名main。

细节补充：
run()方法可调用多次，而start()方法只能调用一次，调用多次将会报错，如下图两图所示：
在这里插入图片描述

六.线程的终止方式

1.使用自定义的全局变量终止线程
特点：终止方法比较温柔，在拿到终止指令后，需要执行完当前的任务才会终止线程

public class ThreadDemo {

    // 全局自定义变量
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        // 转账线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!flag) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("正在讲话...");
                }
                System.out.println("停止说话");
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(310);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 改变变量的值来终止线程
                System.out.println("停止说话，有要事发生。");
                flag = true;
            }
        });
        t2.start();
        t1.join(); //对于用户线程而言，join()可以不写
        t2.join();
    }

}

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

从运行结果我们可以看出，使用全局变量方式“终止说话”后又有一次“正在说话”，这说明全局变量控制线程终止会让当前任务结束后再进行终止。

2.调用线程终止方法interrupt()终止
特点：在收到终止指令后，立马结束进程的执行

①Thread.interrupted()

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        // 转账线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.interrupted()) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        System.out.println("终止状态" +
                                Thread.currentThread().isInterrupted());
                        break;
                    }
                    System.out.println("正在说话...");
                }
                System.out.println("停止了说话");
            }
        });
        t1.start();

        Thread.sleep(310);
        // 终止线程
        System.out.println("停止说话，有要事发生");
        t1.interrupt();
    }
}

程序运行结果：
在这里插入图片描述
②Thread.currentThread().isInterrupted()

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("正在说话");
                }
                System.out.println("停止了说话");
            }
        });
        t1.start();

        Thread.sleep(3);
        System.out.println("停止说话，有要事发生");
        t1.interrupt();
    }
}

在这里插入图片描述

从上面两个图运行结果可以看出，调用interrupt()直接终止正在执行的线程，不管线程是否在执行任务。

那么Thread.interrupted()和Thread.currentThread().isInterrupted()区别是什么呢？通过以下代码运行结果来观察：

①Thread.interrupted()

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

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.interrupted());
//                    System.out.println(Thread.currentThread().isInterrupted());
                }
            }
        });
        t1.start();
        // 终止线程
        t1.interrupt();
    }
}

在这里插入图片描述
②Thread.currentThread().isInterrupted()

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

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    //System.out.println(Thread.interrupted());
                    System.out.println(Thread.currentThread().isInterrupted());
                }
            }
        });
        t1.start();
        // 终止线程
        t1.interrupt();
    }
}

在这里插入图片描述

Thread.interrupted()是全局的方法，执行线程终止状态变为true，之后就会复位为初始默认状态false。Thread.currentThread().isInterrupted()将线程中的终止状态由false变为true，不再复位。

~~3.使用线程提供的方法stop()终止【已弃用】~~

七.线程的状态

线程的状态分为六种：

线程状态	说明
NEW	处于创建状态，此时未调用start()
RUNNABLE	线程运行状态（包含Running执行和Ready就绪）
BLOCKED	阻塞状态
WAITING	等待状态，没有明确的等待时间，如wait()没有参数
TIMED_WAITING	超时等待状态，有明确的等待时间，比如sleep()
TERMINATED	线程结束状态

八.*多线程风险：线程安全

1.什么称作线程不安全？

多线程环境中，程序的执行结果与预期结果不相符，这就叫线程不安全。

线程不安全举例：

public class ThreadDemo7 {

    static class Counter {
        // 定义的私有变量
        private int num = 0;
        // 执行次数
        private final int maxSize = 100000;

        // num++
        public void incrment() {
            for (int i = 0; i < maxSize; i++) {
                num++;
            }
        }

        // num--
        public void decrment() {
            for (int i = 0; i < maxSize; i++) {
                num--;
            }
        }

        public int getNum() {
            return num;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            counter.incrment();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            counter.decrment();
        });
        t2.start();

        t1.join();
        t2.join();

        System.out.println("最终的执行结果：" + counter.getNum());
    }
}

在这里插入图片描述

对于上述代码，我们预期得到的结果为0，然而执行后的结果不为0，这就是线程不安全的例子。

举例分析原因：
使用两个线程对变量count进行一次++和- -。
在这里插入图片描述

原因：Jvm中，线程占有两块内存，其中一个是主内存，另外还有线程自己的工作内存，++和- -操作实际上分为三步完成。

2.线程不安全原因有哪些？

（1）CPU抢占执行
（2）非原子性
（3）编译器优化（指令重排）编译器优化在单线程下执行没问题，多线程下优化会发生混乱
（4）内存的不可见性
（5）多个线程修改了同一个变量

后续更新中。。。

Putarmor

关注

23
点赞
踩
20

收藏

觉得还不错? 一键收藏
23
评论
浅剖Java进程与线程

进程与线程操作系统（OS）概念定位进程一.进程是什么？二.时间片怎么理解？三.并发与并行的理解四.内核态与用户态指的什么？五.进程上下文的认识六.进程的状态有哪些？线程一.线程的认识1.概念2.线程优点3.线程与进程的区别是什么？二.线程的3类创建方式1.继承Thread类创建（2种）2.实现Runable接口（3种）3.实现Callable接口（1种）三.线程的休眠方式1.方式12.方式23.方式3四.线程其他1.例题：使用两个线程打印“AABBCCDD”2.Thread类常用构造方法3.Thread类常
复制链接

扫一扫

专栏目录