Readme

最新推荐文章于 2024-06-12 11:59:04 发布

LongYU3359

最新推荐文章于 2024-06-12 11:59:04 发布

阅读量1.4k

点赞数 25

分类专栏： Java 线程文章标签： java

本文链接：https://blog.csdn.net/m0_59716343/article/details/136313386

版权

Java 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

线程

4 篇文章 0 订阅

订阅专栏

多线程

非常非常非常重要的章节，将分为2部分进行讲授，基础入门以及和集合框架的混用

从面试题目频率的角度上来说，JavaSE部分有2.5个重点：

集合，考核数据结构
线程，Android【Netty】
0.5重点，OOP

基础概念

程序是为完成特定任务、用某种语言编写的一组指令的集合。

程序是指一段静态的代码，是一个静态的概念

进程是具有一定独立功能程序的运行过程，是系统进行资源分配和调度的一个独立单位，重点在系统资源调度的单位，也就是说进程是可以独立运行的一段程序。

进程是程序的一次执行过程，通常是一个可执行程序在内存中的一个完整副本，每个进程都有自己的数据段、栈段和代码段，是一段完整的程序，在内存中占据较大的空间，是系统进行调度和资源分配的一个独立单位。是一个动态的概念
多进程是指操作系统能同时运行多个任务（程序），多线程是指在同一程序中有多个顺序流在执行

线程是进程中的一个独立执行线索，是进程中的一个实体，是CPU调度和分派的基本单位，是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。在运行时，只是暂用一些计数器、寄存器和栈（栈帧）

线程是进程中的一个实体，用来描述进程的执行，它负责执行包括在进程的地址空间中的代码。创建一个进程时，它的第一个线程称为主线程，它由系统自动生成
多线程时指同一程序中有多个顺序流在执行

进程

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

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

启动进程的方法

线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止

cmd /c启动后执行特定的命令，执行完成后自动关闭窗口

ProcessBuilder.start()和Runtime.exec方法创建一个本机进程，并返回Process子类的一个实例，该实例可用来控制进程并获得相关信息。Process类提供了执行从进程输入、执行输出到进程、等待进程完成、检查进程的退出状态以及销毁杀掉进程的方法。

Process类中的方法

void destroy() 杀掉子进程
InputStream getErrorStream() 获取子进程的错误流
InputStream getInputStream() 获取子进程的输入流
OutputStream getOutputStream() 获取子进程的输出流

需求：查看当前机器的网络配置。手工操作步骤为cmd打开终端窗口，然后输入命令ipconfig

ProcessBuilder pb=new ProcessBuilder("cmd","/c","ipconfig/all"); //用于构建进程的对象
Process p=pb.start();//启动进程

BufferedReader br=new BufferedReader(new InputStreamReader(p.getInputStream()));//获取进程的输出内容，注意编码字符集的问题，中文windows下的编码字符集为GBK
String temp=null;
while((temp=br.readLine())!=null)
    System.out.println(temp);
    
//如果使用mac系统则编码为 ProcessBuilder pb=new ProcessBuilder("bash","-c","ifconfig");

写法2：Process process=Runtime.getRuntime().exec(cmd);

String cmd="cmd /c ipconfig/all";
Process process = Runtime.getRuntime().exec(cmd);
InputStream is = process.getInputStream();
BufferedReader br=new BufferedReader(new InputStreamReader(is,"GBK"));
String ss="";
while((ss=br.readLine())!=null)
     System.out.println(ss);

练习：动态生成代码并编译执行

File f = new File("T1.java");
if (f.exists()) f.delete();
// 生成代码文件
PrintWriter pw = new PrintWriter(new FileWriter("T1.java"));
pw.println("public class T1{");
pw.println("public static void main(String[] args) throws Exception{");
pw.println("System.outprintln(\"Hello Java!\");");
pw.println("}}");
pw.close();
 // 编译T1.java javac T1.java
Process process = Runtime.getRuntime().exec("cmd /c javac T1.java");
boolean runnable = true;
// process.getInputStream()用于获取进程的输出信息，不是报错信息。如果需要获取报错信息则应该使用process.getErrorStream()
// javac编译通过实际上是没有响应信息，所以这里获取响应信息是不正确的
BufferedReader br = new BufferedReader(new InputStreamReader(process.getErrorStream()));
while (true) {
    String temp = br.readLine();
    if (temp == null) break;
    System.out.println(temp);
    runnable = false;
}
// 运行T1.class
if (runnable) {
    process = Runtime.getRuntime().exec("cmd /c java T1");
    br = new BufferedReader(new InputStreamReader(process.getInputStream()));
    while (true) {
        String temp = br.readLine();
        if (temp == null) break;
        System.out.println(temp);
    }
}

进程的三大特征

1、独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。

2、动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具备的。

3、并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

僵尸进程和孤儿进程 [*]

僵尸进程是当子进程比父进程先结束，而父进程又没有回收子进程，释放子进程占用的资源，此时子进程将成为一个僵尸进程。如果父进程先退出，子进程被init接管，子进程退出后init会回收其占用的相关资源 —> 是对系统资源的浪费，必须解决

孤儿进程是一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。—> 没有什么危害

并行与并发

并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。

并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS（每秒钟处理的事务数）或者QPS（每秒钟处理的请求数）来反应这个系统的处理能力。

主线程

线程是进程中的一个实体，用来描述进程的执行，它负责执行包括在进程的地址空间中的代码。

创建一个进程时，它的第一个线程称为主线程，它由系统自动生成

它是产生其他子线程的线程

public class Test4 {
   public static void main(String[] args) {
       //Thread[main,5,main]
       System.out.println(Thread.currentThread());
       //主线程的主要功能是启动子线程
       new Thread(){
           @Override
           public void run() {
               //Thread[Thread-0,5,main]
               System.out.println(Thread.currentThread());
           }
       }.start();
   }
}

通常它是最后完成执行，因为它执行各种关闭动作。注意这里不绝对

进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程。

操作系统CPU调度的最小任务单位是线程，操作系统资源调度的最小单位是进程。常用的Windows、Linux等操作系统都采用抢占式多任务，如何调度线程完全由操作系统决定，程序自己不能决定什么时候执行，以及执行多长时间

Java语言内置了多线程支持：一个Java程序实际上是一个JVM进程，JVM进程用一个主线程来执行main()方法，在main()方法内部又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。

线程和进程的区别 [面试**]

1、调度：线程是CPU调度和分配的基本单位，进程是系统资源分配和调度的基本单位。

2、并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行，一个进程至少有一个线程（单进程单线程），一个线程必须隶属于某个进程。

3、拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。

进程和线程最大的区别在于：进程是由操作系统来控制的，而线程是由进程来控制的。

线程本身的数据通常只有寄存器数据以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小

多个进程的内部数据和状态都是完全独立的，而多线程是共享一块内存空间和一组系统资源，有可能互相影响

Thread类

Thread类可以理解为是java用于管理线程的一个类，里面封装了操作系统提供的线程管理这一方面的应用编程接口API，Java代码创建的每个线程都可以理解为Thread实例化的对象，Thread对象用于描述线程的信息。Java标准库中Thread类可以视为是对操作系统对线程管理方面提供的API进行了进一步的抽象和封装。

定义类继承Thread类，并重写Thread类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。因此把run()方法称为线程执行体

需求：计算1+2+3+…+10000=? 不允许使用等差数列的公式，这里例子实际上不建议使用多线程，只是简单的用来理解

启动10个子线程，每个线程计算一部分数据，例如线程1计算1+2+…+1000，线程2计算1001+1002+…+2000，以此类推，最后主线程合并10个线程的计算结果

public class SumThread extends Thread {
    private final int start;
    private final int end;
    private int result;

    public SumThread(int start, int end) {
        this.start = start;
        this.end = end;
    }
    //具体线程的执行逻辑位于run方法中
    @Override
    public void run() {
        for (int k = start; k <= end; k++)
            result += k;
    }
    public int getResult() {
        return result;
    }
}

在主线程中启动10个子线程

public class Test {
    public static void main(String[] args) {
        int res=0;
        Thread[] ts=new Thread[10];
        for(int i=0;i<ts.length;i++){
            int start=i*1000+1;
            int end=(i+1)*1000;
            ts[i]=new SumThread(start,end);
            //启动线程不能直接调用run方法，而是调用start方法。通过start方法启动线程，真正执行的处理逻辑是run方法
            ts[i].start();
        }
        for(Thread t:ts){
            if(t!=null && t instanceof SumThread) {
                SumThread st = (SumThread) t;
                res+=st.getResult();
            }
        }
        System.out.println("计算结果为:"+res);
    }
}

新问题：

执行结果值并不正确：多线程竞争执行，主线程不保证子线程执行完毕才进行累加
多次执行结果值不相同：多线程的执行过程不可重现

查询资料，可以获知[t.join()]则会阻塞当前线程，等待t线程执行结束

public class Test {
    public static void main(String[] args) throws Exception {
        int res=0;
        Thread[] ts=new Thread[10];
        for(int i=0;i<ts.length;i++){
            int start=i*1000+1;
            int end=(i+1)*1000;
            ts[i]=new SumThread(start,end);
            //启动线程不能直接调用run方法，而是调用start方法。通过start方法启动线程，真正执行的处理逻辑是run方法
            ts[i].start();
        }
        for(Thread t:ts){
            if(t!=null && t instanceof SumThread) {
                SumThread st = (SumThread) t;
                st.join();
                res+=st.getResult();
            }
        }
        System.out.println("计算结果为:"+res);
    }
}

如果适用调用run方法

public class Test {
    public static void main(String[] args) throws Exception {
        int res=0;
        Thread[] ts=new Thread[10];
        for(int i=0;i<ts.length;i++){
            int start=i*1000+1;
            int end=(i+1)*1000;
            ts[i]=new SumThread(start,end);
            ts[i].run();
        }
        for(Thread t:ts){
            if(t!=null && t instanceof SumThread) {
                SumThread st = (SumThread) t;
                res+=st.getResult();
            }
        }
        System.out.println("计算结果为:"+res);
    }
}

每次计算结构都正确？

在线程类的run方法种添加输出语句System.out.println(Thread.currentThread());结果发现输出一致，而且都是主线程。
结论：可以直接调用线程类种的run方法，但是不是多线程，而是普通的方法调用。需要启动多线程，必须使用start方法，不能使用run方法

构造器方法

Thread() 创建线程对象

Thread(Runnable) 使用Runnable对象创建线程对象

Thread(String) 创建线程对象，参数为线程名称

Thread(Runnable, String) 使用Runnable接口对象创建线程对象，并对线程命名

Thread(ThreadGroup,Runnable) 线程可以用来分组管理，分好的组即为线程组

常见方法

getId 用来得到线程ID
getName和setName 用来得到或者设置线程名称
getPriority和setPriority 用来获取和设置线程优先级
setDaemon和isDaemon 用来设置线程是否成为守护线程和判断线程是否是守护线程。

守护线程daemon：thread.setDaemon(true)

一般线程没有主线程执行结束后则必须结束的说法，没有这个规则。启动线程的线程和被启动的线程之间没有强制规则
守护线程是当非守护线程结束后会自动结束

public class Test1 {
    public static void main(String[] args) {
        Thread t=Thread.currentThread();
        //启动子线程
        new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("--------");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        System.out.println(t+"执行结束");
    }
}

守护线程

public class Test1 {
    public static void main(String[] args) {
        Thread t=Thread.currentThread();
        //启动子线程
        Thread t1=new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("--------");
                }
            }
        };
        t1.setDaemon(true);//将子线程设置为守护线程
        t1.start();
        System.out.println(t+"执行结束");
    }
}