多线程问题（一）

最新推荐文章于 2024-09-21 10:38:43 发布

过✪

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量380

点赞数 2

分类专栏： JavaEE 文章标签： jvm

本文链接：https://blog.csdn.net/m0_62404808/article/details/128420969

版权

JavaEE 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

本文详细介绍了Java线程的引入原因、线程与进程的区别、五种创建线程的方式，以及start方法与run方法的差异。讨论了线程的属性，如ID、name、状态、优先级等，并讲解了线程中断、等待和休眠的实现方法。此外，还探讨了线程的生命周期和管理策略。

摘要由CSDN通过智能技术生成

2、通过使用Thread类的自带方法进行中断

八、线程等待

九、线程休眠

一、为什么引入线程？

提起线程，不得不首先提到进程，进程就是一段代码的执行过程，在电脑上有很多个进程同时进行，例如听音乐、聊天等等，但是进程所占用的资源较多，就将进程又划分为若干的线程，一个线程就是一个“执行流”，每一个线程按顺序执行自己所负责部分代码，多个线程之间可以并发执行。

相比进程，线程具有以下优势：

线程的创建比进程更快
线程的调度比进程更快
线程的销毁比进程更快

线程常见有三种状态：运行（执行）态、阻塞态、就绪态。

三者的转换图如下：

二、线程和进程的区别

线程包含进程，一个进程由多个线程组成；
进程和线程都能实现并发编程，但是线程的开销比进程少；
进程是系统资源分配的基本单位，线程是系统调度执行的基本单位；
进程与进程之间是相互独立的，各自有独立的虚拟地址空间，但是同一个进程的多个线程共用同一个空间和资源，一个线程出现问题，可能就会影响其他线程。

三、创建线程的五种方式

1、创建类继承Thread类

新建一个类继承Thread类，并重写run方法，run方法中描述的是这个线程要执行的任务，调用start方法表示启动该线程，使线程运行起来。在创建实例时，向上转型，使用Thread类对象接收。

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

2、创建类实现Runnable接口

创建一个类实现Runnable接口，也是要重写run方法，在实例化对象时，需要创建一个实现类作为Thread类构造方法的参数。

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

3、构造Thread类的匿名内部类

这是第一种方法的变形，使用的是匿名内部类，同样也用到了向上转型。

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

4、构造Runnable的匿名内部类

这是第二种方法的变形，创建Runnable匿名内部类完成实例对象。

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

5、使用lambda表达式

这是对第四种方法的升级，使用lambda表达式重写run方法。

public class Test {
    public static void main(String[] args) {
       Thread t=new Thread(()->{
           System.out.println("hello");
       });
       t.start();
    }
}

四、start方法与run方法的区别

start方法：开启线程的方法，内部会在系统中创建线程。

run方法：只是一个普通方法，描述了线程要执行的任务的内容，其并不会创建出线程。

五、线程的构造方法

在实例化线程时，也可以对线程进行命名，使用JDK中自带的jconsole调试工具进行相关调试。

public class Create {
    public static void main(String[] args) {
       Thread t=new Thread(()->{
           System.out.println("hello");
       },"first");
       t.start();
    }
}

六、线程的属性

1、ID

就是线程的编号，默认从0开始。

2、name

线程的名字，可以在实例对象时进行设置。

3、状态

线程的状态有阻塞、就绪和执行三种状态。

4、优先级

在多个线程并发执行时，可以设置优先级决定线程的执行顺序。

5、是否为后台线程

默认创建的线程都不是后台线程，都是前台线程，那么前台线程和后台线程有什么区别？

前台线程会影响线程退出，后台线程不会影响到线程退出。

假设在main方法中创建了t进程：

若t为前台进程，main方法执行完毕后，不能直接退出，必须等到t线程执行完后才能退出；

若t为后台进程，main方法执行完毕后，会直接退出，t线程会被强行终止。

6、是否存活

线程的存活与对象的存活不同，两者的生命周期并不完全一致。

在run方法执行完之前，线程保持存活状态，但是run方法执行结束之后，线程的生命周期也就结束了，线程的整个生命周期从调用start方法开始到run方法执行完结束，但是对象是一直存在的。

7、是否中断

线程在执行过程中，系统可能会出现一些更紧急的问题，让正在执行的线程被迫中断，但是人为也可以让正在执行线程进行中断。

七、线程中断

1、自定义标志位进行中断

自行设置一个标志位作为中断条件，但是这样写并不严谨，后续博客会解释。

public class Test {
    private static boolean flag=true;
    public static void main(String[] args) {
       Thread t=new Thread(()->{
           while(flag){
               System.out.println("hello");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       });
       t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag=false;

    }
}

运行结果：

2、通过使用Thread类的自带方法进行中断

interrupted()方法是一个静态方法，在多线程并发执行时只能使一个线程中断

interrupt()方法是非静态方法，可以通过Thread.currentThread()方法获取到当前线程再调用interrupt方法来实现多个线程中断，在编程中，通常使用该方法。

public class Test {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println(12);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();

    }
}

注意：在进行中断时，一定要在run方法中的捕获sleep异常中的catch添加break ，因为在线程的执行过程中休眠时间长，极大可能在线程休眠期间进行中断，就会触发异常，但是没有break，就会在打印完异常信息之后继续执行run方法，并没有进行中断。

八、线程等待

public void join()

在编程中有时需要等待一个线程执行完之后，另一个线程才开始执行，就要让该线程等待。

join方法也可以设置等待时间。

join方法应该是先执行的线程调用，而不是等待的线程调用。

public class Test{
    public static void main(String[] args) {
       Thread t=new Thread(()->{
           int i=5;
           while(i>0){
               System.out.println("hello");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               i--;
           }
       });
       t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t线程执行结束，main线程可以继续执行");

    }
}