多线程编程(java)

已于 2024-05-08 19:00:50 修改
阅读量868 收藏 14
点赞数 22
文章标签： java 开发语言
于 2024-05-05 16:44:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74235506/article/details/138465018
版权
本文详细介绍了Java中通过Thread类创建线程的五种方法，包括继承Thread、实现Runnable接口、匿名内部类以及Lambda表达式。同时涵盖了线程的启动、中断、等待机制，以及Thread类的属性和线程状态的探讨。
摘要由CSDN通过智能技术生成

目录

Thread 类创建线程(5种方法)

 Thread 类的其他使用方式

Thread 类的属性

线程启动

中断一个线程

线程等待

获取当前线程引用

休眠当前线程

线程的状态

Java如何进行多线程编程?

线程是操作系统的概念, 操作系统提供了一些 API 可以操作线程, Java针对上述系统 API 进行封装, 我们需要掌握这套 API 即可

Thread 类创建线程(5种方法)

注意: Thread是Java标准库内置的类, 平时写程序用到一个类, 需要import, 此处 Thread 不需要 import 也能直接使用, 这是因为 Thread 在 Java.lang 包下

1> 创建一个类继承 Thread

class MyThread extends Thread {
    @Override
    public void run() {
        //线程的入口方法
        while(true) {
            System.out.println("hello thread");
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true) {
            System.out.println("hello main");
        }
    }
}

 每个线程都是一个独立的执行流, 每个线程都可以执行一系列的代码, 一个线程跑起来, 从入口方法开始执行

想启动线程时需要使用t.start(), 而不是 t.run(), 前者是让系统调用API创建出了一个线程, 这个线程再调用  run()  方法, 而后者只是调用了  run()  方法. 这样只会让 run() 方法执行, 打印 hello thread, 而不会打印 hello main; 二者不同看下运行结果.

前者: 两个线程都打印

后者:  只打印run()方法

这两个线程的循环转的太快, 想让它慢一点. 使用sleep 休眠功能

在 Java 种 sleep 是 Thread 的静态方法, static 静态的, 在Java 种 static 作用个 " 静态 " 没有什么关系, Java 中 static 修饰 类方法, 类属性, 对应的的是 实例方法 和 实例属性, 前者 拿着类名直接使用, 后者创建实例化对象才能调用.

sleep 是一个受查异常, 需要显示处理, 此处需要 try catch , 不能throws, 因为此处 run() 重写父类的, 父类没有 throws 

代码例子:

class MyThread extends Thread {
    @Override
    public void run() {
        //线程的入口方法
        while(true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

打印结果如图

在俩线程休眠1000ms后这俩线程谁先执行不一定, 可以视为 " 随机 " 的, 但概率不均等

2>实现Runnable 重写run

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

实现Runnable 后把任务交给线程即可, 两个关键操作即 明确线程执行的任务 和 调用系统 api 创建出线程.

3> 创建一个类继承Thread 使用内部类

让Thread 实现匿名内部类

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

4>实现 Runnable , 重写run, 使用匿名内部类

让Runnable实现匿名内部类

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

            }
        });
        t.start();
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5>基于 lambda 表达式 [推荐]

优点: 更加简洁, 本质上是一个匿名函数(没有名字, 使用一次就完了), 主要用来实现" 回调函数 " 的效果.

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

 Thread 类的其他使用方式

1> Thread()  创建线程对象

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

3> Thread(String name) 创建线程并命名.   就是给线程起个名字, 在调试的时候更方便

Thread 类的属性

属性 : ID   获取方法 : getId()   含义: 线程的身份标识, 表示一个进程中的唯一一个线程, 它是Java分配给线程的, 不是 api 分配的.

属性: 名称  获取方法: getName()  含义:  获取线程名字

属性: 状态  获取方法: getState()   含义:  就绪状态, 阻塞状态....

属性: 优先级  获取方法: getPrionrity()   含义:  获取优先级, 应用程序的角度很难察觉

属性: 是否是后台线程  获取方法: isDaemon()   含义: 一个Java进程中有后台线程, 也有前台线程, 如果前台进程不结束, 整个进程不结束, 前台进程不影响整个进程的结束.

举个例子 : 就是正式场合喝酒, 酒就是前台进程, 菜就是后台进程, 如果不喝完酒就不散场, 喝完的话不管菜吃完不吃完都结束了.

一个线程默认情况是前台进程

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "这是新线程");
        //设置 t 为后台线程
        t.setDaemon(true);
        t.start();

    }
}

改成后台线程之后, 主线程瞬间执行完了, 没有其他前台线程了, 进程结束, t 线程还来不及执行.

属性 是否存活  获取方法: isAlive   含义: Thread 对象的生命周期, 比系统内核中的线程更长一些, 会出现Thread 对象还在, 内核中的线程已经销毁了.

举个例子: 

public class Demo6 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("线程开始");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程结束");
        });
        t.start();
        System.out.println(t.isAlive());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t.isAlive());
    }
}

运行结果:

线程启动

start 方法, start 方法内部使用系统 api, 在该系统内核中创建出线程

run 方法, 单纯描述了该线程执行啥内容( 会在 start 创建好线程中自动调用)

中断一个线程

终止/打断(interrupt)

让一个线程停止运行(销毁)

Java中 此操作的做法 就是让 run 方法尽快执行结束

public class Demo7 {
    public static boolean isQuit = false;
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            //想让这个线程执行完毕, 就得跳出这个循环, 所以增加一个判断条件
            while (!isQuit) {
                //打印换成任意逻辑表示实际工作内容都行
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程工作完毕");
        });
        t.start();
        try {
            Thread.sleep(5000);
            isQuit = true;
            System.out.println("设置 isQuit 为 true");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上述代码正常运行

注意: lambda 中以一个规则: 变量捕获, lambda 表达式里面的代码可以自动捕获到上层作用域中涉及到的局部变量的 ~~ 但是不能改变这个局部变量的值. 改的话会报错. 在上述代码中 isQuit 改为了成员变量, 此时lambda 访问这个成员就不再是变量捕获的语法了, 而是" 内部类访问外部类的属性 ",  此时就没有final之类的限制了, 下面的代码我们将全局变量改为局部变量来看一下.

public class Demo {
    public static void main(String[] args) {
        boolean isQuit = false;
        Thread t = new Thread(() -> {
            System.out.println("线程开始");
            while(!isQuit) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程结束");
        });
        t.start();
        try {
            Thread.sleep(5000);
            isQuit = true;
            System.out.println("设置 isQuit 为 true");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上述代码直接报错, 无法改变 isQuit 的值. 讲这一点主要是了解 lambda 的变量捕获的规则, 就是这个变量不能修改它的值, 也可以将它设置为 final 属性.

上述方案的缺点: 

1> 需要手动创建变量

2> 当线程内部在 sleep 的时候, 主线程修改变量, 新线程内部不能及时响应

我们使用另一种方法(Thread 类内部有一个现成的标志位, 判定当前循环是否要结束)

public class Demo8 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            //其中Thread.currentThread()可以获取到当前线程的实例, 就是 t
            //哪个线程调用这个方法, 就会返回那个线程的对象, 但是不能直接写 t ,还没实例化呢
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("让 t 线程终止");
        //这个操作把Thread 对象内部的标志位设置位true了, 即使线程内部出现阻塞(sleep), 仍然可以用这个方法唤醒
        t.interrupt();
    }
}

运行的结果如图, 我们会发现线程停止后又重新开始了, 这是因为抛出异常后, 系统会自动清除刚才设置的标志位, 这样就是 "设置标志位" 的效果好象没有生效一样

这让我们确定在线程收到":要中断" 的信号时, 能够自动决定接下来怎么处理

三种方式:

1> 直接结束

2>不理会

3>完成接下来的工作在结束

public class Demo8 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            //其中Thread.currentThread()可以获取到当前线程的实例, 就是 t
            //哪个线程调用这个方法, 就会返回那个线程的对象, 但是不能直接写 t ,还没实例化呢
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //1  不理会
                    //2  break;

                    //3  加入工作
                    //3  break;
                }
            }
        });
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("让 t 线程终止");
        //这个操作把Thread 对象内部的标志位设置位true了, 即使线程内部出现阻塞(sleep), 仍然可以用这个方法唤醒
        t.interrupt();
    }
}

上述说法只是在有异常的情况下说明的, 如果没有异常就会直接停止

线程等待

让线程等待另一个线程执行结束再继续执行, 本质上就是控制线程结束的顺序

join 实现线程等待效果

主线程中, 调用t.join(),   此时就是主线程等待t线程结束

例子: 

public class Demo9 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++){
                System.out.println("t 线程工作中!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        //让主线程来等待 t 线程执行结束
        //一旦调用join, 主线程就会触发阻塞, 此时 t 线程就可以趁机完成后续的工作
        //一旦阻塞到 t 线程执行完毕了, join 才会解除阻塞, 才能继续执行
        System.out.println(" join 等待开始");
        t.join();
        System.out.println(" join 等待结束");

    }
}

执行结果如图

 t.join 工作过程

1> 如果 t 线程正在运行中, 此时调用 join 的线程就会阻塞, 一直阻塞到 t 线程执行结束为止

2> 如果 t 线程已经执行结束了, 此时调用 join 线程, 就直接返回了

一般在实际情况下可能会出现死等的情况, 设计开发中最好带有一个超时时间

获取当前线程引用

(public static Thread currentThread())

返回当前线程对象的引用

休眠当前线程

(public static void sleep(long mills) throws interruptedException)

public class Test {
    public static void main(String[] args) throws InterruptedException {
        long beg = System.currentTimeMillis();
        Thread.sleep(1000);
        long end = System.currentTimeMillis();
        System.out.println(end - beg);
    }
}

休眠当前线程 mills 毫秒

输出结果为:

系统由阻塞状态 变成 就绪状态, 被唤醒之后不能立刻到 CPU 上运行, 有一个调度开销, 所以会有误差.

线程的状态

进程的状态最核心的一个是 就绪状态, 一个是阻塞状态 (对于线程同样适用)

Java中有给线程赋予了一些其他的状态

NEW : Thread 对象已经有了. start 方法还没调用

TERMINATED: Thread 对象改在, 内核中的线程已经没了

RUNNABLE: 就绪状态 (线程在cpu上执行了/线程正在排队等待上 CPU 执行)

TIMED_WAITING: 阻塞, 由于 sleep 这种固定时间的方式产生的阻塞

WAITING: 阻塞, 由于 wait 这种不固定时间的方式产生的阻塞

BLOCKED: 阻塞, 由于锁竞争导致的阻塞

public class Demo10 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
            }
        });
        // 在调用 start 之前获取状态, 此时就是 NEW 状态
        System.out.println(t.getState());
        t.start();
        for (int i = 0; i < 5; i++){
            System.out.println(t.getState());
            Thread.sleep(1000);
        }
        t.join();
        // 在线程执行结束之后, 获取线程的状态, 此时是 TERMINATED 状态
        System.out.println(t.getState());
    }
}

在运行开始前 NEW 状态, 开始后 RUNNABLE 状态, 如果在 t 线程中增加sleep会怎样呢?

public class Demo10 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 在调用 start 之前获取状态, 此时就是 NEW 状态
        System.out.println(t.getState());
        t.start();
        for (int i = 0; i < 5; i++){
            System.out.println(t.getState());
            Thread.sleep(1000);
        }
        t.join();
        // 在线程执行结束之后, 获取线程的状态, 此时是 TERMINATED 状态
        System.out.println(t.getState());
    }
}

在sleep()中会变成阻塞状态

小结: 

线程的学习需要理解, 认真思考

-瞬间的永恒-
关注
  • 22
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
同步异步阻塞和非阻塞的区别理解
钟灵毓秀的博客
08-28 864
一、同步和异步 同步和异步是一种 消息通知机制 同步：发出一次请求后必须等到该请求有返回结果，才能继续下一步工作；请求者需主动询问是否有返回结果； 异步：发出一次请求后无需等到该请求有返回结果，即可进行下一步工作；请求有结果后，会以某种方式通知请求者； 同步和异步是相对于操作结果来说，会不会等待结果返回 异步一般通过状态、通知和回调来通知调用者。 状态：即监听被调用者的状态（轮询），调用者需...
多线程编程
yahid的博客
07-24 2972
多线程指的是一个程序中包含两个或者两个以上的线程，多线程的提出是为提高代码的执行效率，这就好比工厂中的流水线，只有一条称为单线程，有多条流水线就成为多线程。多线程提高效率的同时由于并发执行的不确定性，导致出现的结果很多是我们不想要的，所以为了得到我们想要的结果就会在编写多线程的时候加入各种锁，其中最重要的就是synchronized和volatile。在认识它们之前现从多线程最基本的开始。...............
【线程】多线程编程
qq_53830608的博客
11-17 3014
概念 线程是程序中完成一个独立任务的完整执行序列，即一个可调度的实体。 根据运行环境和调度者的身份，县城可分为内核线程和用户线程。 线程运行在内核空间，由内核来调度。 当进程的一个内核线程获得CPU的使用权时，他就加载并执行一个用户线程 线程库负责管理所有执行线程，比如线程的优先级、时间片等。线程库利用longjmp来切换线程的执行，使他们看起来像”并发“执行，但实际内核仍然是把整个进程作为最小单位来调度。 一个进程的所有执行线程共享该进程的时间片，他们对外表现出相同优先级。 线程的实现方式分为三种模式：完
【Java 基础篇】Java多线程编程详解
繁依Fanyi的博客
06-26 2369
本文详细介绍了Java多线程编程的概念、原理和常用技术。多线程编程可以提高程序的性能和响应能力，但也需要注意线程安全和线程同步的问题。在实际开发中，合理地使用多线程可以充分发挥多核处理器的优势，提高程序的并发能力和执行效率。同时，需要注意避免多线程之间的竞争条件和数据一致性问题，保证线程的安全性和正确性。希望本文对你理解和应用Java多线程编程有所帮助！
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程编程
05-02
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过`Thread`类和并发工具来实现，接下来我们将深入探讨这些关键知识点。 1. **...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
JAVA多线程编程实例详解
08-25
JAVA多线程编程实例详解 JAVA多线程编程是指在一个程序中可以同时运行多个线程，以提高程序的执行效率和响应速度。JAVA多线程编程可以通过继承Thread类或实现Runnable接口来实现。 在JAVA中，线程是系统进行资源...
Java语言多线程编程讲义
09-14
Java语言多线程编程讲义 本文对Java语言的多线程编程进行了详细的讲解，涵盖了Java的线程机制、线程的创建、执行、结束、优先级、状态及状态间的转换、共享访问与线程同步、wait和notify在线程间的交互、Thread类的...
Java 多线程编程教程
08-23
Java 多线程编程是Java编程语言中的一个重要特性，它允许程序同时执行多个任务，从而提高了应用程序的效率和响应速度。Java内置了对多线程的支持，使得开发者能够轻松地创建和管理线程。 线程是进程中的一条执行...
java多线程并发编程 核心技术应用实践
最新发布
06-21
Java多线程并发编程是Java开发中的重要领域，它涉及到如何高效地利用计算机资源，特别是在多核处理器系统中，能够显著提升程序的执行效率。在《java多线程并发编程核心技术应用实践》中，我们将深入探讨Java平台上的...
java快递柜多线程+网络编程
10-10
在Java编程领域，多线程和网络编程是两个至关重要的概念，它们在构建高效、分布式系统中发挥着关键作用。本项目"java快递柜"是一个实际应用案例，它结合了这两个技术，旨在模拟一个能够处理并发请求并进行网络通信的...
Java多线程编程指南
06-11
Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。 ...
多线程编程10例
05-06 954
进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows系统。主执行线程终止了，进程也就随之终止。
Lock实现生产者和消费者
weixin_43115582的博客
03-18 145
public static void main(String[] args) { ReentrantLock reentrantLock = new ReentrantLock(); //资源类 Data data = new Data(); new Thread(()->{ for (int i=0;i<10;i++){ try { ..
Java多线程编程深度解析
"Java多线程编程详解，深入详解了Java的线程机制和使用方法，包括多进程多线程概述、Java对多线程的支持、如何创建线程、线程的状态以及通过Runnable接口创建线程等内容。" 在Java编程中，多线程是一个重要的概念，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值