Java超详细讲解多线程中的Process与Thread

更新时间：2022年05月05日 08:42:04 作者：留在梦里

进程process：在一定的环境下，把静态的程序代码运行起来，通过使用不同的资源，来完成一定的任务；线程thread：是程序中一个单一的顺序控制流程。在单个进程中同时运行多个线程完成不同的工作，称为多线程

进程和线程的关系

⭐在操作系统中运行的程序就是进程,比如说QQ,播放器,游戏等等…程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念.

⭐进程和线程都是为了处理并发编程这样的场景,但是进程有问题,频繁拆功创建和释放资源的时候效率低,相比之下,线程更轻量,创建和释放效率更高.

⭐进程具有独立性,每个进程有各自独立的虚拟地址空间,一个进程挂了,不会影响其他进程,同一个进程中的多个线程,共用同一个内存空间,一个线程挂了,可能影响其他的线程,甚至导致整个进程崩溃…

⭐而进程则是执行程序的一次执行过程,他是一个动态的概念,是系统资源分配的单位

⭐通常在一个进程中可以包含多个线程(如果把进程想象成一个工厂,那么线程就是工厂里的生产线,一个工厂里面面可以有一个生产线,也可以有多个生产线),当然一个进程中至少一个线程,不然没有存在的意义,线程是CPU调度和执行的单位.

⭐真正的多线程是指有多个CPU,即多核.

⭐线程就是独立执行的路径

⭐在程序执行时,即使没有自己创建线程,后台也会有多个线程,如主线程,GC线程.

⭐每个线程在自己的工作内存交互,内存操控不当会造成数据不一致.

操作系统是如何管理进程的

1.先描述一个进程.(明确除一个进程上面的一些相关属性)

2.在组织若干个进程.(使用一些数据结构,把很多描述进程的信息放到一起,方便进行增删查改,典型的实现,就是使用双向链表把每个进程的PCB串起来).

并行和并发

并行:微观上,两个CPU核心,同步你是执行两个任务的代码.

并发:微观上,一个CPU核心,先执行一会任务1,在执行一会任务2,在执行一会儿任务3,只要切换足够快,宏观上看起来,就好像很多任务同时执行一样,

并发和并行,只有在微观上可以区分,宏观上区分不了,微观上这里的区分都是都是操作西欧统自动调度的结果.正因为供观赏区分不了并行和并发,在写代码的时候不去区分,只是在研究操作系统进程调度的时候稍做区分,其它场景基本都是使用并发作为一个统称来代替.

创建线程的方法

方法一: 通过Thread类创建线程,这是最简单的方法,创建子类,继承Thread类,并重写run方法.

package thread;
class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

方法二:

import java.util.Scanner;

class MyThread2 extends Thread{
    @Override
    public void run() {
        System.out.println("hello thread!");
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class Demo2 {
    public static void main1(String[] args) {
        Thread t = new MyThread2();
        t.start();
        while (true) {
            System.out.println("hello main!");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

方法三: 创建一个匿名内部类,继承自Thread类,同时重写run方法,同时再new出这个匿名内部类的实例.

import java.util.*;
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("hello!");
    }
}
public class Demo3 {
    public static void main1(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }

方法四: 同样使用了匿名内部类.

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        };
        t.start();
    }
}

方法五: 使用了lambda表达式.

import java.util.*;
public class Demo5 {
    public static void main1(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        });
        t.start();
    }

串行执行和并发执行

public class Demo7 {
    private static final long count = 10_0000_0000;

    public static  void serial(){
        //吉利程序执行时间
        long beg = System.currentTimeMillis();
        long a = 0;
        for (int i = 0; i < count; i++) {
            a++;
        }
        long b = 0;
        for (int i = 0; i < count; i++) {
            b++;
        }
        long end = System.currentTimeMillis();
        System.out.println("消耗时间: "+ (end - beg) + "ms");
    }
    public static void concurrency() throws InterruptedException {
        long beg = System.currentTimeMillis();
        Thread t1 = new Thread(()->{
            long a = 0;
            for (int i = 0; i < count; i++) {
                a++;
            }
        });
        t1.start();
        Thread t2 = new Thread(()->{
            long b = 0;
            for (int i = 0; i < count; i++) {
                b++;
            }
        });
        t2.start();
        //此处布恩那个直接记录结束时间,别忘了,现在这个时间戳的代码是在main 线程中
        //main t1 t2 是并发执行关系,此处t1 t2 还没执行完呢,这里就开始记录结束时间了,这显然是不准确的.
        //正确做法应该是让main线程等地啊t1 t2跑完了,在记录结束时间
        //join 效果就是等待线程结束,t1.join 就是让main 线程等待 t1 结束,t2.join让main 线程等待t2结束
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        System.out.println("消耗时间: "+ (end - beg)+ "ms");
    }
    public static void main(String[] args)throws InterruptedException {
       // serial();
        concurrency();
    }
}

Thread中的一次额重要方法

1.start

决定了系统中是不是真的创建出线程,run单纯的是一个普通的方法,描述了任务的内容,start则是一个特殊的方法,内部会在系统中创建线程.

public class Demo9 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while (true) {
                System.out.println("hello thread1");
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
        t.start();
        //t.run();
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

run方法只是一个普通的方法,在main线程里面调用run,其实并没有创建线程,这个循环仍是在main中执行的.

中断线程

中断线程:让一个线程停下来.

线程停下来的关键,是要让对应的run方法执行完.

(1).可以手动设置一个标志位,来控制线程是否要执行结束.

public class Demo10 {
    private  static boolean isQuit = false;
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while (!isQuit) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
        t.start();
        //只要把这个isQuit 设为true ,此时这个循环就退出了,进一步run 就执行完了,再进一步就是线程结束了
        try{
            Thread.sleep(5000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        isQuit = true;
        System.out.println("终止t线程");
    }
}

(2).使用thread中内置的一个标志位来进行判定.

public class Demo11 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                    //当触发异常之后,立即就退出循环
                    break;
                }
            }
        });
        t.start();
        try{
            Thread.sleep(5000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //在线程中 调用interrupt 方法 来终端这个线程
        //t.interrupt 的意思是让t线程被中断!!
        t.interrupt();
    }
}

线程等待

多个线程之间,调度顺序是不确定的,线程之间的执行是按照调度器来安排的,这个过程可以视为无序或者随机的,有些时候,我们需要控制线程的顺序,线程等待就是其中一种手段,此处的线程等,主要控制线程结束的先后顺.

join: 调用join的时候,那个线程调用的join,那个线程就会阻塞等待,等到对应的线程执行完毕为止(对应线程的run执行完).

public class Demo12 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                System.out.println("hello thread");
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
        t.start();
        //在主线程中可以使用一个等待操作,来等待t线程执行结束
        try{
            t.join(10000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

线程休眠(sleep)

如果线程调用了sleep方法,这个PCB就会进入到阻塞队列.

当睡眠时间到了,系统就会把这个PCB从阻塞队列挪回到就绪队列.

实例:

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true) {
                //z这里啥都不能有
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState());
    }
}

到此这篇关于Java超详细讲解多线程中的Process与Thread的文章就介绍到这了,更多相关Java Process与Thread内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java常用注解扩展对比举例详解
这篇文章主要介绍了Java常用注解扩展对比的相关资料,提供了丰富的代码示例,并总结了最佳实践建议,帮助开发者更好地理解和应用这些注解,需要的朋友可以参考下
2025-03-03
SpringBoot如何在普通类加载Spring容器
这篇文章主要介绍了SpringBoot如何在普通类加载Spring容器,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-04-04
springMVC中@RequestParam和@RequestPart的区别
本文主要介绍了springMVC中@RequestParam和@RequestPart的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
2024-06-06
Java Set集合去重的原理及实现
这篇文章主要介绍了Java Set集合去重的原理及实现，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
2020-09-09
springboot 接收List 入参的几种方法
本文主要介绍了springboot 接收List 入参的几种方法，本文主要介绍了7种方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-03-03
手动实现将本地jar添加到Maven仓库
这篇文章主要介绍了手动实现将本地jar添加到Maven仓库方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-08-08
解析Spring中的静态代理和动态代理
学习 Spring 的过程中，不可避免要掌握代理模式。这篇文章总结一下代理模式。顾名思义，代理，就是你委托别人帮你办事，所以代理模式也有人称作委托模式的。比如领导要做什么事，可以委托他的秘书去帮忙做，这时就可以把秘书看做领导的代理
2021-06-06
Java 将一个字符重复n遍过程详解
这篇文章主要介绍了Java 将一个字符重复n遍过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2019-10-10
Java8如何从一个list中获取某一元素集合
这篇文章主要介绍了Java8如何从一个list中获取某一元素集合，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-07-07
idea ssm项目java程序使用十六进制rxtx包向串口发送指令的方法
这篇文章主要介绍了idea ssm项目java程序向串口发送指令并且使用十六进制 rxtx包,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-08-08