当前位置:网站首页>深入理解多线程(第一篇)

深入理解多线程(第一篇)

2022-08-09 22:11:00 @每天都要敲代码

作者简介:大家好我是@每天都要敲代码,一位材料转码农的选手,希望一起努力,一起进步!
个人主页:@每天都要敲代码的个人主页

系列专栏:JavaSE从入门到精通
推荐一款模拟面试、刷题神器,从基础到大厂面试题点击跳转刷题网站进行注册学习

目录

 一:进程与多线程概述

1.多线程并发的理解 

2.分析程序存在几个线程

二:实现线程的两种方式

1.第一种方式:直接继承Thread,重写run方法

2.第二种方式:实现Runnable接口,重写run方法

3.采用匿名内部类的方式

三:线程生命周期

四:线程简单实操

1.获取线程的名字 & 获取当前线程对象

2.线程的sleep方法

3.终止线程的睡眠 

4.终止线程的执行

5.线程的调度(了解)


 一:进程与多线程概述

什么是进程?什么是线程?
      ️进程是一个应用程序(1个进程是一个软件)
      ️线程是一个进程中的执行场景/执行单元
      ️一个进程可以启动多个线程
️对于java程序来说,当在DOS命令窗口中输入: java HelloWorld 回车之后。
      ️首先会先启动JVM,而JVM就是一个进程。
      ️JVM再启动一个主线程调用main方法。
      ️同时再启动一个垃圾回收线程负责看护,回收垃圾。
      ️所以,最起码现在的java程序中至少有两个线程并发, 一个是垃圾回收线程,一个是执行main方法的主线程。
进程和线程是什么关系?

      ️我们来通过身边的示例来说明一下:

           假如阿里巴巴是一个进程,那么

            马云:阿里巴巴的一个线程
            员工:阿里巴巴的一个线程 
      ️进程可以看做是现实生活当中的公司;线程可以看做是公司当中的某个员工

注意:
      ️进程A和进程B的内存独立不共享。(例如:阿里巴巴和京东资源不会共享的)
          魔兽游戏是一个进程,酷狗音乐是一个进程;这两个进程是独立的,不共享资源。

      ️在java语言中:线程A和线程B,堆内存方法区,内存共享但是栈内存独立一个线程一个栈。
️多线程并发:            
      ️假设启动10个线程会有10个栈空间,每个栈和每个栈之间,互不干扰,各自执行各自的,这就是多线程并发。    
      ️例如:火车站,可以看做是一个进程;火车站中的每一个售票窗口可以看做是一个线程。我在窗口A购票,朋友可以在窗口A购票,朋友不需要等我,我也不需要等朋友;所以多线程并发可以提高效率。

      ️java中之所以有多线程机制,目的就是为了提高程序的处理效率

思考题:
      ️使用了多线程机制之后,main方法结束,是不是有可能程序也不会结束?
        main方法结束只是主线程结束了,主栈空了,其它的栈(线程)可能还在压栈弹栈

       ️我们通过画图理解一下:

1.多线程并发的理解 

分析一个问题:对于单核的CPU来说,真的可以做到真正的多线程并发吗?

    对于多核的CPU电脑来说,真正的多线程并发是没问题的;
        4核CPU表示同一个时间点上,可以真正的有4个进程并发执行。

    什么是真正的多线程并发
            t1线程执行t1的,t2线程执行t2的;t1不会影响t2,t2也不会影响t1。这叫做真正的多线程并发。

    单核的CPU表示只有一个大脑:
       单核的CPU不能够做到真正的多线程并发,但是可以做到给人一种“多线程并发”的感觉!对于单核的CPU来说,在某一个时间点上实际上只能处理一件事情,但是由于CPU的处理速度极快,多个线程之间频繁切换执行,给人来的感觉是:多个事情同时在做!
       例如:线程A:播放音乐,线程B:运行魔兽游戏;线程A和线程B频繁切换执行,人类会感觉音乐一直在播放,游戏一直在运行,给我们的感觉是同时并发的。
       再例如:以前的电影院采用胶卷播放电影,一个胶卷一个胶卷播放速度达到一定程度之后,人类的眼睛产生了错觉,感觉是动画的。这说明人类的反应速度很慢,就像一根钢针扎到手上,到最终感觉到疼,这个过程是需要“很长的”时间的,在这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。

2.分析程序存在几个线程

package com.bjpowernode.java.thread;

/*分析以下程序,有几个线程,除垃圾回收线程之外。有几个线程?
        1个线程(因为程序只有1个栈)*/
public class ThreadTest01 {
    public static void main(String[] args) {
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }

    private static void m1() {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }

    private static void m2() {
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }

    private static void m3() {
        System.out.println("m3 execute!");
    }
}

只有一个主线程(主栈),没有启动分支栈(分支线程);所以只有一个线程!

二:实现线程的两种方式

java支持多线程机制!并且java已经将多线程实现了,我们只需要继承就行了!

1.第一种方式:直接继承Thread,重写run方法

实现线程的第一种方式:

    编写一个类,直接继承java.lang.Thread重写run()方法

    怎么创建线程对象? new就行了,例如: MyThread t = new MyThread()
    怎么启动线程呢? 调用线程对象的start()方法
    start()方法的作用是:启动一个分支线程,在JVM中开辟一个新的栈空间,这段代码任务完成之后,瞬间就结束了。调用start方法的这段代码的任务只是为了开启一个新的栈空间,只要新的栈空间开出来,start()方法就结束了;线程就启动成功了。启动成功的线程会自动调用run方法,并且run方法在分支栈的栈底部(压栈)。 run方法在分支栈的栈底部,main方法在主栈的栈底部;run和main是平级的。

注意:
    亘古不变的道理:方法体当中的代码永远都是自上而下的顺序依次逐行执行的。

如果调用的是t.run,下面分支线程的i执行完,才会执行主线程的i;如果调用的是t.start()主线程和分支线程是一块执行的

我们通过内存图来了解一下:

调用run:

调用start:

package com.bjpowernode.java.thread;

public class ThreadTest02 {
    public static void main(String[] args) {
        // 这里是main方法,这里的代码属于主线程,在主栈中运行。
        // 新建一个分支线程对象
        MyThread t = new MyThread();
        // 启动线程,调用start()方法
        t.start(); // 瞬间就结束了

        //t.run(); // 不会启动线程,不会分配新的分支栈。(这种方式就是单线程。)

        // 这里的代码还是运行在主线程中。
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

class MyThread extends Thread {
    // 重写run方法
    public void run() {
        // 编写程序,这段程序运行在分支线程中(分支栈)。
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

2.第二种方式:实现Runnable接口,重写run方法

第二种方式实现接口比较常用,因为一个类实现了接口,它还可以去继承其它的类,更灵活,面向接口编程;如果是第一种直接就继承了Thread类,类只能单继承,就不能在继承其它类了,比较局限!

package com.bjpowernode.java.thread;

public class ThreadTest03 {
    public static void main(String[] args) {
        // 创建一个可运行的对象
        MyRunnable r = new MyRunnable();
        // 将可执行的对象封装成一个线程对象
        Thread t = new Thread(r);
        
        // Thread t = new Thread(new MyRunnable());// 合并代码

        // 启动线程
        t.start();

        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

class MyRunnable implements Runnable{
    public void run() {
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

3.采用匿名内部类的方式

牵扯到接口,我们也可以不需要在通过实现接口的方式,也可以直接通过匿名内部类的方式去调用!

package com.bjpowernode.java.thread;

public class ThreadTest04 {
    public static void main(String[] args) {
        // 创建线程对象,采用匿名内部类方式
        Thread t = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("分支线程---》"+i);
                }
            }
        });

        // 启动线程
        t.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程---》"+i);
        }
    }
}

三:线程生命周期

线程的生命周期总共有5个状态:新建状态、就绪状态、运行状态、阻塞状态、死亡状态

四:线程简单实操

1.获取线程的名字 & 获取当前线程对象

1、怎么获取当前线程对象

   static Thread currentThread() // 是一个静态方法
   Thread th = Thread.currentThread(); // 返回值th就是当前线程。

2、获取线程对象的名字

String name = 线程对象.getName();

3、修改线程对象的名字

线程对象.setName("线程名字");

4、当线程没有设置名字的时候,默认的名字规律
    Thread-0
    Thread-1
    .....

package com.bjpowernode.java.thread;

public class ThreadTest05 {

    public void doSome(){
        //如果当前类不是线程类,super和this就不行了
        //this.getName();
        //super.getName();
        // 但是这样可以
        String name = Thread.currentThread().getName();
        System.out.println("------->" + name); // main,在main方法里创建的对象
    }

    public static void main(String[] args) {

        ThreadTest05 threadTest05 = new ThreadTest05();
        threadTest05.doSome();

        // 获取当前线程对象
        // currentThread就是当前线程对象
        // 这个代码出现在main方法当中,所以当前线程就是主线程。
        Thread th = Thread.currentThread();
        System.out.println(th.getName()); // main

        // 创建线程对象
        MyThread2 t = new MyThread2();
        // 设置线程的名字
        t.setName("zl-gh");
        // 获取线程的名字
        System.out.println(t.getName()); // zl-gh

        // 如果不设置线程的名字默认是Thread-0 1 2 ......
        MyThread2 t2 = new MyThread2();
        System.out.println(t2.getName()); // Thread-1

        t2.start();
        // 启动线程
        t.start();
    }
}
class MyThread2 extends Thread{
    public void run() {
        for (int i = 0; i < 100; i++) {
            // currentThread就是当前线程对象。当前线程是谁呢?
            // 那个线程调用start()方法,线程执行run方法,那么这个当前线程就是那个
            Thread th = Thread.currentThread();
            System.out.println(th.getName()+"--->"+i);

            // 在这里,super和this也是可以的(当前类是线程类)
            System.out.println(this.getName()+"--->"+i);
            System.out.println(super.getName()+"--->"+i);
        }
    }
}

2.线程的sleep方法

static void sleep(long millis)
1、静态方法:Thread.sleep(1000);
2、参数是毫秒,需要进行异常处理!
3、作用:让当前线程进入休眠,进入“阻塞状态”,放弃占有CPU时间片,让给其它线程使用
4、Thread.sleep()方法,可以做到这种效果:
        间隔特定的时间,去执行一段特定的代码,每隔多久执行一次。

package com.bjpowernode.java.thread;

public class ThreadTest06 {
    public static void main(String[] args) {

        // 使用案例1:
        try {
            // 休眠5秒
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 5秒过后才会打印Hello World
        System.out.println("Hello World");

        // 使用案例2:
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
            try {
                // 让当前线程休眠1秒;没隔1秒打印1个数字
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

关于Thread.sleep()方法的一个面试题:

package com.bjpowernode.java.thread;

public class ThreadTest07 {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new MyThread3(); // 多态
        // 设置线程名字
        t.setName("zl-gh");
        // 启动线程
        t.start();

        // 调用sleep方法
        try {
            // 这段代码不会让线程zl-gh进入休眠状态,和对象没关系
            // t.sleep在执行的时候还是会转换成:Thread.sleep(1000 * 5);
            // 这行代码的作用是:让当前线程进入休眠,也就是说main线程进入休眠。
            // 这样代码出现在main方法中,main线程睡眠。
            t.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 5秒之后这里才会执行。
        System.out.println("Hello World");

    }
}

class MyThread3 extends Thread{
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

3.终止线程的睡眠 

注意:这个不是终断线程的执行,是终止线程的睡眠(唤醒线程)

调用t.interrupt()这种终断睡眠的方式依靠了java的异常处理机制,来终断线程的睡眠

package com.bjpowernode.java.thread;
/*
sleep睡眠太久了,如果希望半道上醒来,你应该怎么办?也就是说怎么叫醒一个正在睡眠的线程??
 */
public class ThreadTest08 {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new Thread(new MyRunnable1());
        // 设置线程名字
        t.setName("zl-gh");
        // 启动线程
        t.start();

        // 希望5秒后,zl-gh线程醒来
        try {
            t.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终断t线程的睡眠
        // 这种终断睡眠的方式依靠了java的异常处理机制
        // 这里终断,下面catch会打印异常信息
        t.interrupt();
    }
}

class MyRunnable1 implements Runnable{
    // 重点:run()当中的异常不能throws,只能try catch
    // 因为run()方法在父类中没有抛出任何异常,子类不能比父类抛出更多的异常。
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->begin");

        try {
            Thread.sleep(1000*60*60*24*365); // 睡眠1年
        } catch (InterruptedException e) {
            //e.printStackTrace(); // 异常信息的打印
        }

        // 一年之后才会执行这段代码
        System.out.println(Thread.currentThread().getName()+"--->end");



        // 调用doOther()
     /*   try {
            doOther(); // 在这里只能try
        } catch (Exception e) {
            e.printStackTrace();
        }*/
    }

    // 其它方法可以throws
    /*public void doOther() throws Exception{

    }*/
}

4.终止线程的执行

强行终止线程的执行

在java中怎么强行终止一个线程的执行;利用t.stop()方法
这种方式存在很大的缺点:容易丢失数据。因为这种方式是直接将线程杀死了,线程没有保存的数据将会丢失。不建议使用。

package com.bjpowernode.java.thread;

public class ThreadTest09 {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new Thread(new MyRunnable3());
        // 设置线程名字
        t.setName("zl-gh");
        // 启动线程
        t.start();

        // 5秒之后强行终止zl-gh线程
        try {
            Thread.sleep(5*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 5秒之后强行终止zl-gh线程
        t.stop(); // 已过时(不建议使用)
    }
}

class MyRunnable3 implements Runnable{
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

合理终止线程的执行(重点)

package com.bjpowernode.java.thread;

public class ThreadTest10 {
    public static void main(String[] args) {
        // 创建线程对象
        MyRunnable4 m = new MyRunnable4();
        Thread t = new Thread(m);
        // 设置线程名字
        t.setName("zl-gh");
        // 启动线程
        t.start();

        // 5秒之后终止zl-gh线程
        try {
            Thread.sleep(5*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止zl-gh线程
        m.run = false;
    }
}

class MyRunnable4 implements Runnable{

    // 打一个布尔标记
    boolean run = true;

    public void run() { // 是true才会执行线程
        for (int i = 0; i < 10; i++) {
            if(run){
                System.out.println(Thread.currentThread().getName()+"--->"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                // false就return结束了,在这里可以进行保存数据的操作
               
                return;
            }

        }
    }
}

5.线程的调度(了解)

1、常见的线程调度模型有哪些?

(1)抢占式调度模型:哪个线程的优先级比较高,抢到的CPU时间片的概率就高一些/多一些;java采用的就是抢占式调度模型

(2)均分式调度模型:平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样;平均分配,一切平等。有一些编程语言,线程调度模型采用的是这种方式。
2、java中提供了哪些方法是和线程调度有关系的呢?

(1)实例方法:
          void setPriority(int newPriority)设置线程的优先级
          int getPriority() 获取线程优先级
          最低优先级1、默认优先级是5、最高优先级10
          优先级比较高的获取CPU时间片可能会多一些。(但也不完全是,大概率是多的) 
(2)静态方法:
          static void yield()  让位方法
          暂停当前正在执行的线程对象,并执行其他线程
          yield()方法不是阻塞方法;让当前线程让位,让给其它线程使用
          yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
          注意:在回到就绪之后,有可能还会再次抢到。
(3)实例方法:
          void join()  合并线程
          例:t.join(); 当前线程进入阻塞t线程执行,直到t线程结束。当前线程才可以继续

5.1 线程优先级

优先级较高的,只是抢到的CPU时间片相对多一些。
大概率方向更偏向于优先级比较高的。

package com.bjpowernode.java.thread;

public class ThreadTest11 {
    public static void main(String[] args) {
        System.out.println("最高优先级"+Thread.MAX_PRIORITY); // 10
        System.out.println("最低优先级"+Thread.MIN_PRIORITY); // 1
        System.out.println("最高优先级"+Thread.NORM_PRIORITY);// 5

        // 获取当前线程对象,获取当前线程的优先级
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName()+
        "线程的优先级是"+currentThread.getPriority()); // main线程的优先级是5

        // 设置主线程的优先级为1
        Thread.currentThread().setPriority(1);

        // 调用下面的线程
        Thread t = new Thread(new MyRunnable5());
        t.setPriority(10); // t线程优先级设置为10
        t.setName("zl-gh");
        t.start();

        // 主线程的for循环
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }

}

class MyRunnable5 implements Runnable{
    public void run() {
        // 获取线程默认的优先级
        // System.out.println(Thread.currentThread().getName()+"线程的优先级"+Thread.currentThread().getPriority()); // zl-gh线程的优先级5

        // t线程的for循环;优先级较高,抢夺的CPU时间片也多,先执行结束
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

5.2 线程让位

让位:当前线程暂停,回到就绪状态,让给其它线程
静态方法:Thread.yield();

package com.bjpowernode.java.thread;

public class ThreadTest12 {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new Thread(new MyRunnable6());
        // 修改线程名字
        t.setName("zl-gh");
        // 启动线程
        t.start();

        for (int i = 1; i <= 10000; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }

}

class MyRunnable6 implements Runnable{
    public void run() {
        for (int i = 1; i <= 10000; i++) {
            // 每100个让位一次
            if(i%100 == 0){
                Thread.yield();// 当前线程暂停一下,让给主线程。
            }
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }

    }
}

5.3 线程合并

实例方法:void join()  合并线程

package com.bjpowernode.java.thread;

public class ThreadTest13 {
    public static void main(String[] args) {
        System.out.println("main begin");
        // 创建线程对象
        Thread t = new Thread(new MyRunnable7());
        // 修改线程的名字
        t.setName("zl-gh");
        // 启动线程
        t.start();

        // 合并线程
        try {
            // t合并到当前线程中,当前线程受阻塞,t线程执行直到结束。
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("main over"); // 最后执行
    }
}

class MyRunnable7 implements Runnable{
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}


 

原网站

版权声明
本文为[@每天都要敲代码]所创,转载请带上原文链接,感谢
https://blog.csdn.net/m0_61933976/article/details/125970340