Java多线程核心技术 -- 深入简知

最新推荐文章于 2022-07-29 10:59:17 发布

庭前云落

最新推荐文章于 2022-07-29 10:59:17 发布

阅读量137

点赞数

分类专栏： Java基础文章标签：多线程 java 面试 python 编程语言

本文链接：https://blog.csdn.net/remsqks/article/details/108586127

版权

Java基础专栏收录该内容

20 篇文章 0 订阅

订阅专栏

多线程程序的引入图解

1、多线程理解

即在同一时间，可以做多件事情。

进程：正在执行的应用程序

启动一个 LOL.exe 就叫一个进程
线程：进程的执行单元，执行路径

就是在进程内部同时做的事情，比如：上路被敌方打野击杀，我方打野击杀对面ad
单线程：一个应用程序只有一条执行路径
多线程：一个应用程序有多条执行路径

1.1、多线程的意义？

提高应用程序的使用率

多进程的意义：提高CPU的使用率

1.2、Java程序的运行原理及JVM的启动是多线程的吗？

运行原理：Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。
JVM的启动：JVM的启动时多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程

1.3、多线程的实现方案

继承Thread类
- 1、自定义类 Mythread 继承 Thread 类
- 2、在 Mythread 类中重写 run()；
  - run()里面封装的是被线程执行的代码
- 3、创建 MyThread 类的对象
- 4、启动线程对象
  - 启动线程对象用的是start()
  - start()和run()区别？，
    - run() 直接调用仅仅是普通方法
    - start() 先启动线程，再由JVM调用 run()方法
```
public class Mythread extends Thread{

    private Hero h1;
    private Hero h2;

    public Mythread(Hero h1, Hero h2){
        this.h1 = h1;
        this.h2 = h2;
    }

    public void run(){
        while(!h2.isDead()){
            h1.attackHero(h2);
        }
    }
}
```

实现Runnable接口

1、自定义类 MyRunnable 实现 Runnable 接口
2、在 MyRunnable 类中重写 run()
3、创建 MyRunnable 类的对象
4、创建 Thread 类的对象，并把第三步骤的对象作为构造参数传递

public class MyRunnable implements Runnable{

    private Hero h1;
    private Hero h2;

    public MyRunnable(Hero h1, Hero h2){
        this.h1 = h1;
        this.h2 = h2;
    }

    public void run(){
        while(!h2.isDead()){
            h1.attackHero(h2);
        }
    }
}

那么这两个实现方案有什么不同呢？
- 继承 Thread 可以避免由于 Java 单继承带来的局限性
- 实现 Runnable 接口，适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想

1.4、线程的调度和优先级问题

线程的调度
- 分时调度：
  
  所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
- 抢占式调度(Java采用的调度方式)：
  
  优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取 CPU 时间相对会多一些。
获取和设置优先级
- public final int getPriority()
- public final void setPriority(int newPriority)
- 默认是5
- 范围是1~10

1.5、线程的控制(常用方法)

线程休眠(当前线程暂停)

public class TestThread {
    public static void main(String[] args) {
        Thread t1= new Thread(){
            public void run(){
                int seconds =0;
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.printf("已经玩了LOL %d 秒%n", seconds++);
                }              
            }
        };
        t1.start();     
    }   
}

线程加入(加入到当前线程中)

所有进程，至少会有一个线程即主线程，即main方法开始执行，就会有一个看不见的主线程存在。执行join，表明在主线程中加入该线程。主线程会等待该线程结束完毕，才会往下运行。
```
public final void join(){

}
```
礼让线程
```
public static void yield(){

}
```

后台线程

public final void setDaemon(boolean on){

}

终止线程（掌握）

//两种方式
public final void stop(){

}
public void interrupt(){

}

1.6、线程的生命周期

新建：创建线程对象
就绪：有执行资格，没有执行权
运行：有执行资格，有执行权
阻塞：由于一些操作让线程处于该状态。没有执行资格，没有执行权。而另一些操作可以把它给激活，激活后处于就绪状态。
死亡：线程对象变成垃圾，等待回收

1.7、线程安全问题的原因

即我们以后判断一个程序是否有线程安全问题的依据

是否有多线程环境
是否有共享数据
是否有多条语句操作共享数据

1.8、同步解决线程安全问题

线程的状态转换图

常见情况：

1：新建--就绪--运行--死亡
2：新建--就绪--运行--就绪--运行--死亡
3：新建--就绪--运行--其他阻塞--就绪--运行--死亡
4：新建--就绪--运行--同步阻塞--就绪--运行--死亡
5：新建--就绪--运行--等待阻塞--同步阻塞--就绪--运行--死亡

同步的前提
- 多个线程
- 多个线程使用的是同一个锁对象
同步的弊端

当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

假设问题：

团战一触即发，对面抱团中推，吸血鬼在侧面找机会进场，E闪R红Q点燃，R到4人，同时被对面集火，奶妈给了个大招保了下来，配合上二段R回复，瞬间满血，完成收割。

这里吸血鬼进场承受伤害：有多个线程在减少吸血鬼的hp
同时，吸血鬼自身回复、二段大招回复，以及奶妈大招：有多个线程在恢复吸血鬼的hp
假设线程数量一致，并且每次改变的值都是1，那么血量应该不变

但是你会发现有时运行会看到错误的数据产生

public class Hero{
    public String name;
    public float hp;
     
    public int damage;
     
    //回血
    public void recover(){
        hp=hp+1;
    }
     
    //掉血
    public void hurt(){
        hp=hp-1;
    }
     
    public void attackHero(Hero h) {
        h.hp-=damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);
        if(h.isDead())
            System.out.println(h.name +"死了！");
    }
  
    public boolean isDead() {
        return 0>=hp?true:false;
    }
  
}

分析原因：

1、得到的血量值是5000

2、假设先回血，进行增加运算(应为5000+1)

2、正在计算恢复量时，减少线程来了(减少线程得到的是原数值5000，而不是增加后的数值5001)

3、结果减少线程得到的值是4999，最后的值就是4999

虽然先加后减了，期望的数值应为 5000 原数值不变，但是此时却是4999。在业务上被称为脏数据。

解决方案，就是在运算期间，在一个线程运行结束前，其他线程不可以访问原数据

同步代码块

//这里的锁对象可以是任意对象。该对象如同锁的功能
synchronized(对象) {
   需要被同步的代码;
}

同步方法
- 就是把同步关键字加到方法上
  
  如果锁对象是this，就可以考虑使用同步方法。否则能使用同步代码块的尽量使用同步代码块
```
//这里的锁对象是this
把同步加在方法上
```

静态同步方法

//这里的锁对象是当前类的字节码文件对象(之前写的反射有讲字节码文件对象)
把同步加在方法上。

死锁问题
- 指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象
  
  如果出现了同步嵌套，就容易产生死锁问题

1.9、多线程面试题

1:多线程有几种实现方案，分别是哪几种?
两种。
继承Thread类
实现Runnable接口

扩展一种：实现Callable接口。这个得和线程池结合。

2:同步有几种方式，分别是什么?
两种。

同步代码块
同步方法

3:启动一个线程是run()还是start()?它们的区别?
run():封装了被线程执行的代码,直接调用仅仅是普通方法的调用
start():启动线程，并由JVM自动调用run()方法

4:sleep()和wait()方法的区别
sleep():必须指时间;不释放锁。
wait():可以不指定时间，也可以指定时间;释放锁。

5:为什么wait(),notify(),notifyAll()等方法都定义在Object类中
因为这些方法的调用是依赖于锁对象的，而同步代码块的锁对象是任意锁。
而Object代码任意的对象，所以，定义在这里面。

6:线程的生命周期图
新建 -- 就绪 -- 运行 -- 死亡
新建 -- 就绪 -- 运行 -- 阻塞 -- 就绪 -- 运行 -- 死亡
建议：画图解释。