什么是线程
在操作系统中, 一个应用程序的执行实例就是进程, 进程有独立的内存空间和系统资源, 在任务管理器中可以看到进程.
线程是 CPU 调度和分派的基本单位, 也是进程中执行运算的最小单位, 可完成一个独立的顺序控制流程, 当然一个进程中可以有多个线程.
多线程: 一个进程中同时运行了多个线程, 每个线程用来完成不同的工作. 多个线程交替占用 CPU 资源, 并非真正的并行执行.
使用多线程能充分利用 CPU 的资源, 简化编程模型, 带来良好的用户体验.
一个进程启动后拥有一个主线程, 主线程用于产生其他子线程, 而且主线程必须最后完成执行, 它执行各种关闭动作.
在 Java 中 main() 方法为主线程入口, 下面使用 Thread 类查看主线程名.
- public class MainThread {
- public static void main(String[] args) {
- // 获取当前线程
- Thread t=Thread.currentThread();
- System.out.println("当前线程名字:"+t.getName());
- // 自定义线程名字
- t.setName("MyThread");
- System.out.println("当前线程名字:"+t.getName());
- }
- }
创建线程
在 Java 中创建线程有两种方式
1. 继承 java.lang.Thread 类
2. 实现 java.lang.Runnable 接口
1. 继承 Thread 类创建线程
(1) 定义 MyThread 类继承 Thread 类
(2) 重写 run() 方法, 编写线程执行体
- public class MyThread extends Thread{
- // 重写 run 方法
- @Override
- public void run() {
- for (int i = 1; i <= 10; i++) {
- System.out.println(Thread.currentThread().getName()+":"+i);
- }
- }
- }
(3) 创建线程对象, 调用 start() 方法启动线程
- public class TestMyThread {
- public static void main(String[] args) {
- MyThread myThread=new MyThread();
- // 启动线程
- myThread.start();
- }
- }
多个线程同时启动后是交替执行的, 线程每次执行时长由分配的 CPU 时间片长度决定
修改 TestMyThread.java 观察多线程交替执行
- public class TestMyThread {
- public static void main(String[] args) {
- MyThread myThread1=new MyThread();
- MyThread myThread2=new MyThread();
- myThread1.start();
- myThread2.start();
- }
- }
多运行几次观察效果
启动线程能否直接调用 run() 方法?
不能, 调用 run() 方法只会是主线程执行. 调用 start() 方法后, 子线程执行 run() 方法, 主线程和子线程并行交替执行.
2. 实现 Runnable 接口创建线程
(1) 定义 MyRunnable 类实现 Runnable 接口
(2) 实现 run() 方法, 编写线程执行体
- public class MyRunnable implements Runnable{
- // 实现 run 方法
- @Override
- public void run() {
- for (int i = 1; i <= 10; i++) {
- System.out.println(Thread.currentThread().getName()+":"+i);
- }
- }
- }
(3) 创建线程对象, 调用 start() 方法启动线程
- public class TestMyRunnable {
- public static void main(String[] args) {
- Runnable runnable=new MyRunnable();
- // 创建线程, 传入 runnable
- Thread t=new Thread(runnable);
- t.start();
- }
- }
线程的生命周期
创建状态: 线程创建完成, 比如 MyThread thread=new MyThread
就绪状态: 线程对象调用 start() 方法, 线程会等待 CPU 分配执行时间, 并没有立马执行
运行状态: 线程分配到了执行时间, 进入运行状态. 线程在运行中发生礼让 (yield) 会回到就绪状态
阻塞状态: 执行过程中遇到 IO 操作或代码 Thread.sleep(), 阻塞后的线程不能直接回到运行状态, 需要重新进入就绪状态等待资源的分配.
死亡状态: 自然执行完毕或外部干涉终止线程
线程调度
线程调度指按照特定机制为多个线程分配 CPU 的使用权
线程调度常用方法
方法 | 说明 |
---|---|
setPriority(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
void join() | 等待该线程终止 |
static void yield() | 暂停当前正在执行的线程对象,并执行其他线程 |
void interrupt() | 中断线程 |
boolean isAlive() | 测试线程是否处于活动状态 |
线程优先级的设置
线程优先级由 1~10 表示, 1 最低, 默认有限级为 5. 优先级高的线程获得 CPU 资源的概率较大.
- public class TestPriority {
- public static void main(String[] args) {
- Thread t1=new Thread(new MyRunnable(),"线程 A");
- Thread t2=new Thread(new MyRunnable(),"线程 B");
- // 最大优先级
- t1.setPriority(Thread.MAX_PRIORITY);
- // 最小优先级
- t2.setPriority(Thread.MIN_PRIORITY);
- t1.start();
- t2.start();
- }
- }
线程休眠
让线程暂时睡眠指定时长, 线程进入阻塞状态, 睡眠时间过后线程会再进入可运行状态.
休眠时长以毫秒为单位, 调用 sleep() 方法需要处理 InterruptedException 异常.
- public class TestSleep {
- public static void main(String[] args) {
- for (int i = 1; i <= 10; i++) {
- System.out.println("第"+i+"秒");
- try {
- // 让当前线程休眠 1 秒
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- }
强制运行
使用 join() 方法实现, 可以认为是线程的插队, 会先强制执行插队的线程.
- public class JoinThread implements Runnable{
- @Override
- public void run() {
- for (int i = 1; i <=10; i++) {
- System.out.println("线程名:"+Thread.currentThread().getName()+"i:"+i);
- }
- System.out.println("插队线程执行完毕!");
- }
- }
- public class TestJoin {
- public static void main(String[] args) {
- Thread joinThread=new Thread(new JoinThread(),"插队的线程");
- // 启动后与主线程交替执行
- joinThread.start();
- for (int i = 1; i <= 10; i++) {
- if (i==5) {
- try {
- System.out.println("==== 开始插队强制执行 ====");
- joinThread.join();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- System.out.println("线程名:"+Thread.currentThread().getName()+"i:"+i);
- }
- System.out.println("主线程执行完毕!");
- }
- }
最一开始执行, 主线程 main 和 "插队的线程" 是交替执行. 当主线程的循环到第 5 次的时候, 调用 "插队的线程" 的 join 方法, 开始强制执行 "插队的线程", 待 "插队的线程" 执行完后, 才继续恢复 main 线程的循环.
线程礼让
使用 yield() 方法实现, 礼让后会暂停当前线程, 转为就绪状态, 其他具有相同优先级的线程获得运行机会.
下面我们实现 Runnable 接口, 在 run 方法中实现礼让, 创建两个线程, 达到某种条件时礼让.
- public class YieldThread implements Runnable{
- @Override
- public void run() {
- for (int i = 1; i <= 10; i++) {
- System.out.println("线程名:"+Thread.currentThread().getName()+"i:"+i);
- // 当前线程执行到 5 后发生礼让
- if (i==5) {
- System.out.println(Thread.currentThread().getName()+"礼让:");
- Thread.yield();
- }
- }
- }
- }
- public class TestYield {
- public static void main(String[] args) {
- Thread t1=new Thread(new YieldThread(),"A");
- Thread t2=new Thread(new YieldThread(),"B");
- t1.start();
- t2.start();
- }
- }
只是提供一种可能, 不能保证一定会实现礼让
线程同步
首先看一个多线共享同一个资源引发的问题
仓库有 10 个苹果, 小明, 小红, 小亮每次可以从仓库中拿 1 个苹果, 拿完苹果后仓库中的苹果数量 - 1.
先编写仓库资源类, 实现接口
- // 这个实现类将被多个线程对象共享
- public class ResourceThread implements Runnable{
- private int num=10;
- @Override
- public void run() {
- while(true) {
- if (num<=0) {
- break;
- }
- num--;
- try {
- Thread.sleep(300);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(Thread.currentThread().getName()+"拿走一个, 还剩余:"+num);
- }
- }
- }
编写测试类, 创建两个线程对象, 共享同一个资源
- public class TestResource {
- public static void main(String[] args) {
- ResourceThread resource=new ResourceThread();
- // 使用同一个 Runnable 实现类对象
- Thread t1=new Thread(resource,"小明");
- Thread t2=new Thread(resource,"小红");
- Thread t3=new Thread(resource,"小亮");
- t1.start();
- t2.start();
- t3.start();
- }
- }
运行后我们发现, 每次拿完苹果后的剩余数量出现了问题, 使用同步方法可以解决这个问题.
语法:
访问修饰符 synchronized 返回类型 方法名 (参数列表){
......
}
synchronized 就是为当前的线程声明一个锁
修改 ResourceThread.java 实现同步
- // 这个实现类将被多个线程对象共享
- public class ResourceThread implements Runnable{
- private int num=10;
- private boolean isHave=true;
- @Override
- public void run() {
- while(isHave) {
- take();
- }
- }
- // 同步方法
- public synchronized void take() {
- if (num<=0) {
- isHave=false;
- return;
- }
- num--;
- try {
- Thread.sleep(300);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(Thread.currentThread().getName()+"拿走一个, 还剩余:"+num);
- }
- }
实现同步的第二种方式同步代码块
语法:
- synchronized(syncObject){
- // 需要同步的代码
- }
syncObject 为需同步的对象, 通常为 this
修改 ResourceThread.java 改为同步代码块
- // 这个实现类将被多个线程对象共享
- public class ResourceThread implements Runnable{
- private int num=10;
- private boolean isHave=true;
- @Override
- public void run() {
- while(isHave) {
- synchronized(this) {
- if (num<=0) {
- isHave=false;
- return;
- }
- num--;
- try {
- Thread.sleep(300);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(Thread.currentThread().getName()+"拿走一个, 还剩余:"+num);
- }
- }
- }
- }
来源: https://www.cnblogs.com/AIThink/p/9858875.html