『Java练习生的自我修养』java-se进阶¹ • 初识多线程

☕☕ Java进阶攻坚克难，持续更新，一网打尽IO、注解、多线程…等

java-se

进阶内容。

🐋线程的基本概念

🎈程序、进程、与线程？

👉🏻想要搞明白什么是线程，首先要对程序与进程有一个清晰的概念，大学课堂上的《操作系统》这门课开篇就是这部分内容，学过这门课的同学对程序、进程和线程应该已经不陌生了。

程序（program）： 为完成特定任务，用某种语言编写的一组指令集合，程序是静态的，这是它与进程的区别。

进程（process）： 程序的一次执行过程，或是正在运行的一个程序，进程强调的是动态的过程。

👉🏻在不引入线程这个概念之前，进程是系统运行时资源分配和调度的基本单位。为了充分利用系统资源，提高程序的运行效率，将进程进一步细化为线程，取代进程成为了调度和执行的基本单位。

✨线程（Thread）的特点：

1. 线程是程序内部的一条执行路径；
2. 每个线程拥有独立的运行栈和程序计数器（PC），线程之间切换的开销小；
3. 一个进程中的多个线程共享相同的内存单元，可以访问相同的变量和对象；
4. 线程之间的通信简便、高效，但是多个线程访问同一资源时也会带来安全隐患。
5. 如果只有一个CPU时，多线程是模拟出来的，只能称作并发执行，当有多个CPU即多核的状态下，多个线程才是真正的同时执行，可以称作并行。

🎈并行与并发的区别

并行： 多个CPU同时执行多个任务。

并发： 一个CPU同时执行多个任务。这里的“同时”并不是真的有多个任务在同时执行，CPU在一次还是只能执行一个任务，每个任务执行一段时间后就切换其他任务，只不过CPU的速度很快，看起来像是多个任务在同时执行。（操作系统讲到的CPU时间片轮转调度算法就是典型的并行执行例子）

🎈线程的几种状态

🎈何时需要多线程？

1. 程序需要同时执行两个或多个任务；
2. 程序需要实现一些需要等待的任务，比如用户输入，文件读写，搜索等等；
3. 需要后台运行的程序…

🦮线程的创建与使用

👉🏻JVM启动我们的Java程序以后，进程中会有默认的线程，比如Main主方法线程与GC垃圾回收线程。通常我们编写的代码都是在Main主方法线程中执行的，又称作用户线程，而GC垃圾回收线程称作守护线程。

✨Java中想要自己创建线程，有以下三种方式：✨

1. Thread class —▶ 继承Thread类
2. Runnable接口 —▶ 实现Runnable接口
3. Callable接口 —▶ 实现Callable接口

🎯1.继承Thread类

继承Thread类，并重写其中的

run()

方法，通过调用

start()

方法开启线程。

//    方式一：继承Thread类//    1.创建子类classMyThreadextendsThread{//    2.重写run()方法@Overridepublicvoidrun(){System.out.println("创建一个线程");}}publicclassTest{publicstaticvoidmain(String[] args){//        3.创建对象MyThread myThread =newMyThread();//        4.调用start（）
        myThread.start();}}

写一个小Demo，看一下我们自己创建的线程与主方法线程在运行时的顺序：

（为了避免CPU运行速度过快看不出多线程的效果，可以将循坏次数设置的大一些）

classMyThreadextendsThread{@Overridepublicvoidrun(){for(int i =0; i <300; i++){System.out.println("***这是自己创建的线程***MyThread---");}}}publicclassDemo{publicstaticvoidmain(String[] args){newMyThread().start();for(int i =0; i <300; i++)System.out.println("***这是主方法默认线程***Main---");}}

运行，可以看到即便代码中是先运行MyThread线程，但是两个线程中的输出语句是交替出现的。

🎯2.实现Runnable接口

声明实现类Runnable接口，并实现其中的

run()

方法，然后分配类的实例，在创建Thread时作为参数传递（这里用了静态代理设计模式），调用Thread下的

start()

方法启动。

//  方式二：实现Runnable接口classMyThreadimplementsRunnable{//    实现run()方法线程体@Overridepublicvoidrun(){System.out.println("创建一个线程");}}publicclassTest{publicstaticvoidmain(String[] args){//        2.创建Runnable接口的实现类对象MyThread myThread =newMyThread();//        3.创建线程对象并传递参数，通过线程对象开启我们的线程newThread(myThread).start();}}

使用匿名内部类的方式传递Runnable接口的实现类，让代码更简洁灵活：

publicclassTest{publicstaticvoidmain(String[] args){newThread(newRunnable(){@Overridepublicvoidrun(){System.out.println("创建一个线程");}}).start();}}

JDK1.8新特性，通过Lambda表达式进一步简化代码：

publicclassTest{publicstaticvoidmain(String[] args){newThread(()->{System.out.println("创建一个线程");}).start();}}

🎯3.实现Callable接口

Callable接口创建线程的流程：

实现Callable接口→重写call方法→创建目标对象→ 创建执行服务→提交执行→获取结果→关闭服务

importjava.util.concurrent.*;//  方式三：实现Callable接口//     实现Callable接口classTestCallableimplementsCallable<Boolean>{//    实现call()方法，执行结束后返回一个值@OverridepublicBooleancall()throwsException{System.out.println("创建一个线程");returntrue;}}publicclassTest{publicstaticvoidmain(String[] args)throwsExecutionException,InterruptedException{//        创建目标对象TestCallable t =newTestCallable();//        创建执行服务ExecutorService ser =Executors.newFixedThreadPool(1);//        提交执行Future<Boolean> r = ser.submit(t);//        获取结果boolean res = r.get();//        关闭服务
        ser.shutdown();}}

🐈线程方法

方法说明setPriority(int newPriority)更改线程优先级static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠void join()等待该线程终止static void yield()暂停当前正在执行的线程对象，并执行其他线程void interrupt()中断线程，不推荐使用boolean isAlive()测试线程是否处于活动状态
调用线程方法可以控制线程的运行状态：

停止线程：

• JDK提供的stop()、destroy()方法已经废弃，不推荐使用。
• 推荐让线程自己停下来。
• 建议使用一个标志位，当flag=false时终止线程运行。

🍦Demo案例：

classMyThreadimplementsRunnable{//    1.设置一个标志位privateboolean flag =true;@Overridepublicvoidrun(){int i =0;while(flag){System.out.println("Thread is running..."+ i++);}}//    2.设置一个公开的方法停止线程，转换标志位publicvoidstop(){this.flag =false;}}publicclassTestStop{publicstaticvoidmain(String[] args){MyThread myThread =newMyThread();//        运行myThread线程newThread(myThread).start();//        当主线程循环到180次时结束myThreadfor(int i =0; i <300; i++){System.out.println("***main***"+ i);if(i ==180){
                myThread.stop();System.out.println("myThread线程已经停止");}}}}

🍦运行结果：

线程休眠：

• sleep(long millis)指定当前线程阻塞的毫秒数。
• sleep(long millis)方法存在异常InterruptedException。
• sleep时间达到后线程进入就绪状态。
• sleep可以模拟网络延时、倒计时等。
• 多线程环境下，每个对象都有一个锁，sleep不会释放锁。

🍦Demo案例：

importjava.text.SimpleDateFormat;importjava.util.Date;publicclassTestSleep{//    打印当前系统时间publicstaticvoidmain(String[] args)throwsInterruptedException{//        获取当前时间Date time =newDate(System.currentTimeMillis());while(true){//            每隔1s打印一次时间Thread.sleep(1000);System.out.println(newSimpleDateFormat("HH:mm:ss").format(time));//            更新时间
            time =newDate(System.currentTimeMillis());}}}

🍦运行结果：

线程礼让：

• 调用yield()方法即可让当前正在执行的线程暂停，但不阻塞。
• 将线程从运行态转为就绪态。
• CPU会重新调度，但线程礼让不一定成功，取决于系统的调度。

强制执行：

• 调用join()方法合并线程，其他线程阻塞，待此线程执行完成后，再执行其他线程。

查看线程状态：

调用

getState()

方法查看线程状态：

• NEW — 线程尚未启动。
• RUNNABLE — 线程正在执行。
• BLOCKED — 线程被阻塞。
• WATTIGN — 线程正在等待另一个线程执行特定动作。
• TIMED_WATTING — 正在等待另一个线程执行动作到达指定等待时间。
• TERMINATED — 线程已经退出。

🍦示例代码：

publicclassTestState{publicstaticvoidmain(String[] args){Thread myThread =newThread(()->{for(int i =0; i <3; i++){try{Thread.sleep(1000);}catch(InterruptedException e){
                    e.printStackTrace();}System.out.println("这是一个线程");}});//        查看线程状态Thread.State state = myThread.getState();System.out.println(state);//        观察启动后
        myThread.start();System.out.println(myThread.getState());}}

🍦输出结果：

NEW
RUNNABLE
这是一个线程
这是一个线程
这是一个线程

Process finished with exit code 0

线程优先级：

• Java提供线程调度器来监控程序中进入就绪状态的线程，线程调度器按照优先级进行调度，但是需要注意优先级不是一定生效，实际的调度顺序取决与CPU调度，只不过优先级高的被先调度的概率会高一些。
• 线程优先级用数字表示，1~10： - Thread.MIN_PRIORITY = 1- Thread.MAX_PRIORITY = 10- Thread.NORM_PRIORITY = 5
• 获取或改变优先级： - getPriority()- setPriority(int x)
• 只能先设置优先级再启动线程，反过来不行。

🐄守护线程

👉🏻线程分为用户线程与守护线程，操作日志、内存监控、垃圾回收等都属于守护线程。虚拟机只需要确保用户线程执行完毕，而不用等待守护线程也执行完。

👉🏻通过

setDaemon(boolean x)

方法设置守护线程，默认值是

false

，代表用户线程，正常的线程都是用户线程，

setDaemon(true)

将线程切换为守护线程。

🍦代码示例：

publicclassTestDaemon{publicstaticvoidmain(String[] args){//        设置用户线程执行20次Thread userThread =newThread(()->{for(int i =0; i <20; i++){System.out.println("***我是一个用户线程***"+ i);}});//        设置守护线程执行100次Thread daemonThread =newThread(()->{for(int i =0; i <100; i++){System.out.println("---我是一个守护线程---"+ i);}});//        将线程设定为守护线程
        daemonThread.setDaemon(true);
        userThread.start();
        daemonThread.start();}}

🍦运行结果：

可以发现即便代码部分守护线程循环了100次，但是用户线程结束，整个程序都会结束，JVM不会再等待守护线程也执行完。

🦌线程池技术

如果用过数据库连接池的同学对线程池也有一定概念了，它们都属于池化技术，目的就是提高程序的性能。

📍为什么需要线程池？

频繁创建和调用线程尤其是并发情况下的线程，对性能的影响很大。如果提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池中，可以有效避免线程的频繁创建销毁，实现重复利用。

📍引入线程池技术的好处：

• 降低资源消耗。
• 便于线程管理。
• 提高响应速度，减少创建新线程的时间。

📍使用线程池：

JDK5.0版本提供的线程池工具类：ExecutorService 和 Executors，其中Executors是线程池的工厂类，用于创建并返回不同类型的线程池，ExecutorService是真正的线程池接口。

• Executors.newFixedThreadPool(int parm)方法返回一个线程池池，参数执行线程池的大小。
• ExecutorService类下的execute(Runnable command)方法用于将线程丢进线程池并执行线程。
• 线程执行完毕后可以使用shutdown()方法关闭线程池链接。

🍦线程池编程3步：

importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;classMyThreadimplementsRunnable{@Overridepublicvoidrun(){//        循环输出线程名称+循环次数for(int i =0; i <10; i++){System.out.println(Thread.currentThread().getName()+" :"+ i);}}}publicclassDemo{publicstaticvoidmain(String[] args){//        1.创建线程池ExecutorService service =Executors.newFixedThreadPool(10);//        2.将线程丢进线程池并启动
        service.execute(newMyThread());
        service.execute(newMyThread());
        service.execute(newMyThread());
        service.execute(newMyThread());//        3.关闭线程池链接
        service.shutdown();}}

🍦执行结果：

💙🧡💙🧡💙🧡💙🧡💙

🤍💬下篇预告：并发与多线程🤍

💛💚💛💚💛💚💛💚💛

🍍🍍🍍
创作不易，如果觉得本文对你有所帮助，欢迎点赞、关注、收藏。🙇🏻‍♀️
🍉🍉🍉
@作者：Mymel_晗，计算机专业练习时长两年半的Java练习生~🏃🏻‍♂️🏀

🔸🔹文末已至，咱们下篇再见🔹🔸

┊一片春愁待酒浇。江上舟摇，楼上帘招。┊一剪梅·舟过吴江-蒋捷