前言
本文为Java多线程相关知识，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~
一、Java多线程简要概述
1.线程的核心概念
线程就是独立执行的路径
在程序运行时，即使没有自己创建线程，后台也会有多个线程，比如 主线程，gc线程
main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果避开了多个线程，现成的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
对同一份资源进行操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如cpu调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
二、线程的创建
1.继承Thread
- 继承Thread类，重写run方法，调用Start()方法开启线程
- 不建议使用：为了避免OOP单继承的局限性
代码展示：
package com.wang.多线程; // 创建线程方法一：继承Thread类，重写run方法，调用Start()方法开启线程 public class ThreadTest1 extends Thread { @Override public void run() { for (int i = 0; i < 1200; i++) { System.out.println("Thread多线程" + i); } } public static void main(String[] args) { ThreadTest1 threadTest = new ThreadTest1(); // 创建一个线程对象 threadTest.start(); // 调用start()方法开启线程 for (int i = 0; i < 1200; i++) { System.out.println("main主线程" + i); } } } // 打印结果 main主线程0 Thread多线程0 Thread多线程1 Thread多线程2 Thread多线程3 Thread多线程4 main主线程1 Thread多线程5 ..... 可以看得出来，这两个线程是同时在进行的
2.实现Runnable接口
- 重写run方法，执行线程需要丢入runnable接口实现类。调用start()方法
- 推荐使用：很好的避免了单继承的局限性，灵活方便，同一个对象被多个线程使用
代码展示
package com.wang.多线程; public class RunnableTest implements Runnable{ @Override public void run() { for (int i = 0; i < 1200; i++) { System.out.println("Runnable线程:" + i); } } public static void main(String[] args) { RunnableTest runnableTest = new RunnableTest(); new Thread(runnableTest).start(); for (int i = 0; i < 1200; i++) { System.out.println("main方法：" + i); } } } // 打印结果 main方法：0 Runnable线程:0 Runnable线程:1 Runnable线程:2 main方法：1 main方法：2 main方法：3 main方法：4 Runnable线程:3 ....
3.实现Callable接口
- 创建一个实现Callable接口的类，实现call方法。将操作声明在call里。
- 创建Callable接口实现类的对象。然后创建执行服务，在提交服务，最后记得要关闭服务
代码展示：
package com.wang.多线程; import java.util.concurrent.*; public class CallableTest1 implements Callable<Boolean> { @Override public Boolean call() throws Exception { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "Callable:" + i); } return true; } public static void main(String[] args) throws Exception{ CallableTest1 callableTest1 = new CallableTest1(); CallableTest1 callableTest2 = new CallableTest1(); CallableTest1 callableTest3 = new CallableTest1(); // 创建执行服务 ExecutorService executorService = Executors.newFixedThreadPool(3); // 提交执行 Future<Boolean> future1 = executorService.submit(callableTest1); Future<Boolean> future2 = executorService.submit(callableTest2); Future<Boolean> future3 = executorService.submit(callableTest3); // 获取结果 boolean b1 = future1.get(); boolean b2 = future2.get(); boolean b3 = future3.get(); System.out.println(b1); System.out.println(b2); System.out.println(b3); // 关闭服务 executorService.shutdownNow(); } } // 打印 pool-1-thread-3Callable:2 pool-1-thread-3Callable:3 pool-1-thread-3Callable:4 pool-1-thread-3Callable:5 pool-1-thread-3Callable:6 pool-1-thread-3Callable:7 pool-1-thread-1Callable:0 pool-1-thread-2Callable:0 pool-1-thread-2Callable:1 看这个3Callable和1Callable还有2Callable同时在输出
三、线程状态
1.五大状态
- 创建状态
- 就绪状态
- 运行状态
- 阻塞状态
- 死亡状态
如图所示：
2.停止线程
- 使用标志位方式
代码展示：
package com.wang.多线程; public class StopThread_04 implements Runnable{ // 设置标志位 private boolean stop = true; @Override public void run() { int i = 0; while (stop) { System.out.println("Run...." + i); } } // 写一个标志位，用来停止某个线程 public void stop() { this.stop = false; } public static void main(String[] args) { StopThread_04 stopThread = new StopThread_04(); new Thread(stopThread).start(); for (int i = 0; i < 500; i++) { System.out.println("main...." + i); if (i == 490) { // 调用stop方法停止线程 stopThread.stop(); System.out.println("run线程停止了"); } } } } // 打印 main....0 Run....0 main....1 Run....0 main....2 Run....0 ... main....490 Run....0 run线程停止了
3.线程休眠（阻塞状态）
PS:每一个对象都有一把锁，sleep不会释放锁
sleep()的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。
代码展示：
package com.wang.多线程; import java.text.SimpleDateFormat; import java.util.Date; // 线程休眠 public class ThreadSleep_05 { public static void main(String[] args) throws InterruptedException { // ThreadSleep_05.tenDown(); // 这个方法是模拟倒计时 // 模拟打印系统当前时间 Date Time = new Date(); // 获取当前时间 while (true) { Thread.sleep(1000); // 休眠1秒 long time = Time.getTime(); // 将时间转换为long类型 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss"); // 将获取的时间格式化 String format = simpleDateFormat.format(time); // 将long类型的时间转换为字符串形式 System.out.println(format); Time = new Date(); // 从新获取时间起到更新时间的作用 } } // 模拟倒计时 public static void tenDown() throws InterruptedException { int num = 30; while (true) { Thread.sleep(1000); System.out.println(num--); if (num <= 0) { break; } } } } // 打印 14:05:04 14:05:05 14:05:06 14:05:07 14:05:08 14:05:09 14:05:10 14:05:11 即休眠一秒
4.线程礼让
- 首先礼让是不一定成功的
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转为就绪状态
代码展示：
package com.wang.多线程; public class ThreadYield_06 implements Runnable{ public static void main(String[] args) { ThreadYield_06 threadYield = new ThreadYield_06(); new Thread(threadYield, "轿车").start(); new Thread(threadYield, "货车").start(); } @Override public void run() { System.out.println(Thread.currentThread().getName() + "线程开始"); Thread.yield(); // 线程礼让方法 System.out.println(Thread.currentThread().getName() + "线程结束"); } } // 打印情况1：礼让成功 货车线程开始 轿车线程开始 货车线程结束 轿车线程结束 // 礼让不成功 轿车线程开始 轿车线程结束 货车线程开始 货车线程结束
5.合并线程(插队)
- 顾名思义插队就是有些线程它需要优先去执行
代码展示：
package com.wang.多线程; public class ThreadJoin_07 implements Runnable { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("vip插队" + i); } } public static void main(String[] args) { ThreadJoin_07 threadJoin = new ThreadJoin_07(); Thread thread = new Thread(threadJoin); thread.start(); for (int i = 0; i < 500; i++) { if (i == 150) { // 当i= 150 时，开始插队，插队线程执行完另一个才会继续 try { thread.join(); // 插队方法 } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("main" + i); } } } // 打印 main149 vip插队64 vip插队65 vip插队66 vip插队67 .... vip插队997 vip插队998 vip插队999 main150 main151
6.观察状态
代码展示：
package com.wang.多线程; public class StateThread_08 { public static void main(String[] args) { Thread thread = new Thread( () -> { for (int i = 0; i < 5; i++) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(">>>>>>>>>>>>>"); }); // 观察状态 Thread.State state = thread.getState(); System.out.println(state); // NEW 尚未启动的线程处于此状态。 // 观察启动后 thread.start(); // 启动线程 state = thread.getState(); System.out.println(state); // RUNNABLE 在Java虚拟机中执行的线程处于此状态。 while (state != Thread.State.TERMINATED) { // 只要线程不终止，就一直输出 try { Thread.sleep(100); state = thread.getState(); // 更新线程状态 System.out.println(state); // TIMED_WAITING 线程处于阻塞（等待）状态 } catch (InterruptedException e) { e.printStackTrace(); } } } }
四、线程优先级
1.线程优先级
- 优先级一共分为1-10 越大级别越高 默认情况下为5
- 最重要的一点，并不是一定高的就执行快。线程的优先级和执行顺序无关
代码展示：
package com.wang.多线程; public class ThreadPriority implements Runnable{ public static void main(String[] args) { System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority()); ThreadPriority threadPriority = new ThreadPriority(); Thread thread1 = new Thread(threadPriority); Thread thread2 = new Thread(threadPriority); Thread thread3 = new Thread(threadPriority); Thread thread4 = new Thread(threadPriority); Thread thread5 = new Thread(threadPriority); Thread thread6 = new Thread(threadPriority); // 设置优先级 thread1.start(); thread2.setPriority(5); thread2.start(); thread3.setPriority(9); thread3.start(); thread4.setPriority(10); thread4.start(); thread5.setPriority(2); thread5.start(); thread6.setPriority(3); thread6.start(); } @Override public void run() { System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority()); } } // 打印 main--->5 Thread-0--->5 Thread-2--->9 Thread-1--->5 Thread-3--->10 Thread-5--->3 Thread-4--->2 由此可以看出10级并没有第一个执行完
后记
本文下接：【多线程】一文搞懂Java多线程，代码示例，清晰明了（下）
Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~
