3.系统学习JavaEE：多线程

最新推荐文章于 2024-07-14 22:18:32 发布

爱塔居

最新推荐文章于 2024-07-14 22:18:32 发布

阅读量605

点赞数 6

分类专栏： JavaEE 文章标签： java

本文链接：https://blog.csdn.net/m0_65683419/article/details/129547671

版权

JavaEE 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

作者：爱塔居

专栏：JavaEE

作者介绍：大三学生，希望跟大家一起进步

文章目录

上章节回顾

1.线程的概念

线程之间资源共享，开销小，效率高。

2.进程和线程的区别

进程包含线程。（盖棺定论）一个进程里面至少有一个线程。进程是操作系统资源分配的基本单位。线程是操作系统进行调度执行的基本单位。

3.java代码如何创建线程

1）继承Thread，重写run

2）实现Runnable，重写run

3）继承Thread，匿名内部类

4）实现Runnable，匿名内部类

5）lambda表达式（推荐使用）

4.Thread常见属性

start方法：真正从系统这里，创建一个线程，新的线程将会执行run方法。

run方法表示了线程的入口方法是啥。（线程启动起来，要执行哪些逻辑。不是让程序员调用，要交给系统去自动调用）

一、中断线程

中断一个线程

中断这里就是字面意思，就是让一个线程停下来。线程的终止，本质上说，办法只有一种，就是让该线程的入口方法执行完毕。

1.1 给线程中设定一个结束标志位。

把循环条件用一个变量来控制：

package threading;
public class ThreadDemo6 {
    public static  boolean isQuit=false;
    public static void main(String[] args) {
        Thread t=new Thread(()-> {
            while (!isQuit){
                System.out.println("hello t");
                try{
                    Thread.sleep(1000);//休息1秒
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println("t 线程终止");
        });
        t.start();
        //在主线程中，修改isQuit
        try {
            Thread.sleep(3000);//主线程休息三秒
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        isQuit=true;//将isQuit值改成true
    }
}

如果把isQuit从成员变量改成局部遍历main。该代码能否正常工作？

不能。因为变量捕获。

lambda表达式能否访问外面的局部变量？可以，变量捕获语法规则。java要求变量捕获，捕获的变量必须是final或者实际final（变量没有用final修饰，但是代码中没有做出修改）。

1.2 interrupt()

package threading;
public class ThreadDemo7 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            //currentThread是获取当前线程实例
            //此处currentThread得到的对象就是t
            //isInterrupted是t对象里自带的一个标志位
          while (!Thread.currentThread().isInterrupted()){
              System.out.println("hello t");
              try {
                  Thread.sleep(1000);
              }catch (InterruptedException e){
                  e.printStackTrace();//打印出当前异常位置的调用栈
              }
              }
        });
        t.start();
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //把t内部的标志位设置成true
        //如果该进程阻塞中，就会把阻塞状态唤醒，通过抛出异常的方式，让sleep结束。
        t.interrupt();//只执行一次
    }
}

注意：当sleep被唤醒的时候，sleep会自动地把isInterrupted标志位给清空（true->fasle)

调用interrupt，设置了中断标志位，sleep第一次执行，清空了标志位，变成false，并抛出异常。sleep第二次执行，没有这个中断的标志位了。主线程并非是循环反复设置，而是只执行一次。

如果设置interrupt的时候，恰好，sleep刚醒。着生活，执行到下一轮的循环的条件后，也就直接结束了。不过这种概率很低，毕竟sleep的时间已经占据了整个循环体的99.999999999%的时间了。

多线程的代码执行顺序不是“从上到下”，而是每个线程独立执行的。

多线程的调式是比较麻烦的。因为调试运行的效果和实际运行的效果可能差异很大。比如你给t线程打断点了，此时main线程仍然正常执行。

针对多线程的调试，最主要的方法是打印日志。

package threading;
public class ThreadDemo7 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            //currentThread是获取当前线程实例
            //此处currentThread得到的对象就是t
            //isInterrupted是t对象里自带的一个标志位
          while (!Thread.currentThread().isInterrupted()){
              System.out.println("hello t");
              try {
                  Thread.sleep(1000);
              }catch (InterruptedException e){
                  e.printStackTrace();//打印出当前异常位置的调用栈
                  break;
              }
              }
        });
        t.start();
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //把t内部的标志位设置成true
        //如果该进程阻塞中，就会把阻塞状态唤醒，通过抛出异常的方式，让sleep结束。
        t.interrupt();
    }
}

当我们加上break，这个代码就能正常结束了。

1.3为什么sleep要清空标志位呢？

清空标志位的目的是让线程本身能够对于线程何时结束，有一个更明确的控制。

当前的interrupt方法效果，并不是让线程立即结束，而是告诉他，你该结束了，至于他是否真的要结束，立即结束还是等会结束，都是代码来灵活控制的。

比如，你在打游戏的时候，妈妈让你帮忙到楼下扔个垃圾。

这时候，你要选择放下手机，立马去丢垃圾，还是跟妈妈说等会再去，还是直接说，我要打游戏，不丢垃圾呢？

很明显，我们会先试试跟妈妈商量，“妈，打完这把，我就去丢垃圾。马上就打完了。”如果妈妈不同意，我们就会放下手机，赶紧下楼丢垃圾。

如果，我们在上网课，认真学习的时候，妈妈进来说，你去楼下丢个垃圾。

我们坚决跟妈妈说：“不。我正忙着听课呢。”

interrupt只是建议，不是命令。

为什么java不强制设定为“命令结束”的操作呢？只要调用interru就立即结束呢？

因为设定成这种，非常不友好。

我们在打游戏的时候，说去丢垃圾，还能理解。毕竟，打游戏是一种娱乐。可是，正在认真学习，你二话不说，让我立马去丢垃圾，就很不合理了。

线程t何时结束，一定是t自己最清楚。交给t自己决定，就比较好。

二、等待一个线程—join（）

线程之间是并发执行的。操作系统对于线程的调度是无序的，无法判定两个线程谁先执行结束，谁后执行结束。

package threading;

public class ThreadDemo8 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            System.out.println("hello t");
        });
        t.start();
        System.out.println("hello main");
    }
}

我们先输出hello main 还是输出hello t是无法确定的。这个代码实际执行的时候，大概率先输出hello main。毕竟创建线程，是需要开销的。不过不排除特定情况。

我们是不喜欢不确定的，会出概率性的bug，很难受。有的时候，我们就要明确规定线程的结束顺序。

我们可以使用线程等待来实现。

package threading;

public class ThreadDemo8 {
    public static void main(String[] args) throws InterruptedException{
        Thread t=new Thread(()->{
            System.out.println("hello t");
        });
        t.start();
        t.join();
        System.out.println("hello main");
    }
}

t.join()是在main线程中，调用t.join。意思是让main线程等待t先结束，再往下执行。

如果是在t1线程中，调用t2.join，就是让t1线程等待t2先结束。

在t。join执行的时候，如果t线程还没有结束，main线程就会阻塞等待。阻塞就是代码走到这一行就停下了，当前线程暂时不参与cpu的调度执行。

如果只有两个线程，main等待t，如果t短时间不结束，那是不是就不算并发了？

main阻塞了，不参加cpu调度了，此时就只有t去执行，单个线程确实也谈不上并发。

1.main线程调用t.join的时候，如果t还在运行，此时main线程阻塞，知道t执行完毕（t的run执行完了），main才从阻塞中解除，才继续执行。

2.main线程调用t.join的时候，如果t已经结束了，此时join不会阻塞，就会立即往下执行。

这两种情况都能保证t是先结束的。

join还有一个版本，可以填写一个参数，作为“超时时间”，等待的最大时间。

join的无参数版本，效果就是“死等”，不见不散。

join的有参数版本，则是执行最大超时时间，如果等待的时间到了上限，还没有等到，咱就不等了。

会不会有两个线程互相等待的情况

会有的。那种情况称为死锁，是bug。比如家钥匙锁车里了，车钥匙锁家里了。

三、线程的状态

操作系统里的线程，自身是有一个状态的。但是Java Thread是对系统线程的封装，把这里的状态又进一步地精细化了。

NEW 系统中地线程还没创建出来呢，只是有一个Thread对象。

package threading;

public class ThreadDemo9 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            System.out.println("hello t");
        });
        System.out.println(t.getState());
    t.start();
    }
}

输出结果：

TERMINATED 系统中的线程已经执行完了，Thread对象还在。

package threading;

public class ThreadDemo9 {
    public static void main(String[] args)throws InterruptedException {
        Thread t=new Thread(()->{
            System.out.println("hello t");
        });
        System.out.println(t.getState());
        t.start();
        Thread.sleep(2000);
        System.out.println(t.getState());
    }
}

RUNNABLE 就绪状态

1）正在CPU上运行。

2）准备好随时可以去CPU上执行。

package threading;

public class ThreadDemo9 {
    public static void main(String[] args)throws InterruptedException {
        Thread t=new Thread(()->{
            while (true){
               // System.out.println("hello t");
            }

        });
        System.out.println(t.getState());
        t.start();
        Thread.sleep(2000);
        System.out.println(t.getState());
    }
}

TIMED_WAITNG 指定时间等待.sleep方法。

package threading;

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

BLOCKED 表示等待锁出现的状态

WAITING 使用wait方法出现的状态

一条主线，三个支线。理解线程状态，意义就是让我们能够更好地进行多线程代码的调试。

四、多线程带来的风险-线程安全（重点）

本章的重点，难点，考点。‘某个代码，在多线程环境下执行，会出bug=》线程不安全

举例子：

创建两个线程，各执行5w次自增。正常情况，结果是10w。

package threading;
//线程不安全
class Counter{
    private int count=0;
    public void add(){
        count++;
    }
    public int get(){
        return count;
    }
}
public class ThreadDemo10 {
    public static void main(String[] args) throws InterruptedException{
        Counter counter=new Counter();
        //搞两个线程，两个线程分别对这个counter自增5w次
        Thread t1=new Thread(()->{
            for (int i = 0; i <50000 ; i++) {
                counter.add();
            }
        });
        t1.start();
        Thread t2=new Thread(()-> {
            for (int i = 0; i < 50000; i++) {
                counter.add();
            }
        });
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.get());
    }
}

输出结果：