Java笔记032-多线程基础/线程相关概念、线程基本使用、继承Thread VS 实现Runnable的区别、线程终止、线程常用方法、线程的声明周期

企业开发 2023-06-05 01:27:35 阅读次数: 0

多线程基础

线程相关概念

程序(program)

是为完成特定任务、某种语言编写的一组指令的合集

进程

  1. 进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间

  1. 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生。存在和消亡的过程

线程

  1. 线程是由进程创建的，是进程的一个实体

  1. 一个进程可以拥有多个线程

其他相关概念

  1. 单线程：同一时刻，只允许执行一个线程

  1. 多线程：同一个时刻，可以执行多个线程，比如：一个QQ进程，可以同时开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

  1. 并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发

  1. 并行：同一时刻，多个任务同时执行，多核cpu可以实现并行

  1. 并发和并行可能同时存在

线程基本使用

创建线程的两种方式

在Java中线程来使用有两种方法

  1. 继承Thread类，重写run方法

  1. 实现Runnable接口，重写run方法

线程应用案例1-继承Thread类

  1. 请编写程序，开启一个线程，该线程每隔1秒。控制台输出“喵喵，我是小喵咪”

  1. 对上题改进：当输出80次“喵喵，我是小喵咪”，结束该进程

  1. 使用JConsole监控线程执行情况，并画出程序示意图

package com17.threaduse;

/**
 * @author 甲柒
 * @version 1.0
 * @title Thread01
 * @package com17.threaduse
 * @time 2023/3/21 20:43
 */
public class Thread01 {
    public static void main(String[] args) {
        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();
        cat.start();//启动线程->最终会执行cat的run方法
        //解读源码
        //
        /*(1)
            public synchronized void start() {
                start0();
            }
          (2)
          //start0() 是本地方法，是JVM调用，底层是c/c++实现
          //真正实现多线程的效果，是start0()，而不是run
            private native void start0();
         */
        //cat.run();//run方法就是一个普通的方法，没有真正地启动一个线程，就会把run方法执行完毕，才向下执行
        //说明：当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
        //这时 主线程和子线程是交替执行...
        System.out.println("主线程继续执行~~~" + Thread.currentThread().getName());//名字main
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

//说明
//1、当一个类继承了 Thread类，该类就可以当线程使用
//2、重写run方法，写上自己的业务代码
//3、run Thread 类 实现了 Runnable 接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class Cat extends Thread {
    int times = 0;

    @Override
    public void run() {//重写run方法，写上自己的业务逻辑
        while (true) {
            //开启一个线程，该线程每隔1秒。控制台输出“喵喵，我是小喵咪”
            System.out.println("喵喵，我是小喵咪" + (++times) + "线程名=" + Thread.currentThread().getName());
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (times == 80) {
                break;//当times到8，退出while，这时线程也就退出..
            }
        }

    }
}

线程应用案例2-实现Runnable接口

说明

  1. Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了

  1. Java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

应用案例

请编写程序，该程序可以每隔1秒，在控制台输出“hi!”，当输出10次后，自动退出。请使用实现Runnable接口的方式实现

package com17.threaduse;

/**
 * @author 甲柒
 * @version 1.0
 * @title Thread02
 * @package com17.threaduse
 * @time 2023/3/22 23:06
 * 通过实现接口Runnable 来开发xiancheng
 */
public class Thread02 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
        dog.start();
//        //创建Thread对象，把dog对象(实现Runnable)，放入Thread
//        Thread thread = new Thread(dog);
//        thread.start();
        Tiger tiger = new Tiger();//实现了Runnable
        Proxy proxy = new Proxy(tiger);
        proxy.start();
    }
}

class Dog implements Runnable {//通过实现Runnable接口 开发线程
    int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("小狗汪汪叫.. hi" + (++count) + Thread.currentThread().getName());

            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (count == 10) {
                break;
            }
        }
    }
}

class Animal {
}

class Tiger extends Animal implements Runnable {
    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫~~~~");
    }
}

//线程代理类，模拟了一个极简的Thread类
class Proxy implements Runnable {//可以把Proxy类当成 ThreadProxy
    private Runnable target = null;//属性 类型是 Runnable

    public Proxy(Runnable target) {
        this.target = target;
    }

    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定(运行类型Tiger)
        }
    }

    public void start() {
        start0();//这个方法是真正实现多线程 的方法
    }

    public void start0() {
        run();
    }

}

线程应用案例3-多线程执行

请编写一个程序，创建两个线程，一个线程每隔1秒输出“hello,world”，输出10次，退出，一个线程每隔1秒输出“hi”，输出5次退出

package com17.threaduse;

/**
 * @author 甲柒
 * @version 1.0
 * @title Thread03
 * @package com17.threaduse
 * @time 2023/3/27 11:10
 */
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();//启动第1个线程
        thread2.start();//启动第2个线程
    }
}

class T1 implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while (true) {
            //每隔1秒输出“hello,world”，输出100次
            System.out.println("hello,world " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (count == 100) {
                break;
            }
        }
    }
}

class T2 implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while (true) {
            //每隔1秒输出“hi”，输出50次
            System.out.println("hi " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (count == 50) {
                break;
            }
        }
    }
}

线程如何理解

继承Thread VS 实现Runnable的区别

  1. 从Java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从JDK帮助文档来看，Thread类本身就实现了Runnable接口

  1. 实现Runnable接口方式更加适合多线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable接口

T3 t3 = new T3("hello ");
Thread thread01 = new Thread(t3);
Thread thread02 = new Thread(t3);
thread01.start();
thread02.start();

System.out.println("主线程完毕");

使用多线程模拟售票系统

[售票系统]，编程模拟三个售票窗口售票，分别使用继承Thread和实现Runnable方式，并分析有什么问题

package com17.ticket;

/**
 * @author 甲柒
 * @version 1.0
 * @title SellTicket
 * @package com17.ticket
 * @time 2023/3/27 11:41
 * 使用多线程，模拟三个窗口同时售票 100张
 */
public class SellTicket {
    public static void main(String[] args) {
//        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里会出现票数超卖现象
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程

        System.out.println("=====使用Runnable接口方式实现=====");
        SellTicket02 sellTicket02 = new SellTicket02();

        //这里也会出现票数超卖现象
        new Thread(sellTicket02).start();//第1个线程-窗口
        new Thread(sellTicket02).start();//第2个线程-窗口
        new Thread(sellTicket02).start();//第3个线程-窗口
    }
}

//使用Thread方式
class SellTicket01 extends Thread {
    private static int ticketNum = 100;//让多个线程共享ticketNum

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束~~~");
            }
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数 " + (--ticketNum));
        }
    }
}

//实现接口方式
class SellTicket02 implements Runnable {
    private static int ticketNum = 100;//让多个线程共享ticketNum

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束~~~");
            }
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数 " + (--ticketNum));
        }
    }
}

线程终止

基本说明

  1. 当线程完成任务后，会自动退出

  1. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

package com17.exit_;

/**
 * @author 甲柒
 * @version 1.0
 * @title ThreadExit_
 * @package com17.exit_
 * @time 2023/3/27 12:06
 */
public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //希望main线程去控制 t1线程的终止，必须可以修改loop
        //让t1 退出run方法，从而终止 t1线程 -> 通知方式

        //让主线程休眠10秒，再通知t1线程退出
        System.out.println("main线程休眠10s....");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}

class T extends Thread {
    int count = 0;
    //设置一个控制变量
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);//让当前线程休眠50ms
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("AThread 运行中~~~" + (++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程常用方法

常用方法第一组

  1. setName //设置线程名称，使之与参数name相同

  1. getName //返回该线程的名称

  1. start //使该线程开始执行；Java虚拟机底层调用该线程的start0方法

  1. run //调用线程对象run方法

  1. setPriority //更改线程的优先级

  1. getPriority //获取线程的优先级

  1. sleep //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

  1. interrupt //中断线程

注意事项和细节

  1. start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程

  1. 线程优先级的范围

  1. interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程

  1. sleep：线程的静态方法，使当前线程休眠

package com17.method;

/**
 * @author 甲柒
 * @version 1.0
 * @title ThreadMethod01
 * @package com17.method
 * @time 2023/3/28 22:32
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("甲柒");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();//启动子线程

        //主线程打印5 hi ，然后就中断 子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }

        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());

        t.interrupt();//当执行到这里时，就会中断 t 线程的休眠
    }
}

class T extends Thread {//自定义的线程类

    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "  休眠中~~~~");
                Thread.sleep(20000);//20s
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
                //InterruptedException 是捕获获得到一个中断异常
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
//                throw new RuntimeException(e);
            }
        }
    }
}

常用方法第二组

  1. yield：线程的礼让。让出cpu，让其他线程执行，但礼让时间不确定，所以也不一定礼让成功

  1. join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

案例：创建一个子线程，每隔1s输出hello，输出20次，主线程每隔1秒，输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续，

package com17.method;

/**
 * @author 甲柒
 * @version 1.0
 * @title ThreadMethod02
 * @package com17.method
 * @time 2023/3/28 23:04
 */
public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for (int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程吃了 " + i + " 个 包子");
            if (i == 5) {
                System.out.println("主线程 让 子线程 先吃");
                //join 线程插队
               t2.join();//相当于让t2线程先执行完毕
//                Thread.yield();//礼让 不一定成功
                System.out.println("子线程吃完了 主线程继续");
            }
        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1s
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("子线程吃了 " + i + " 个 包子");
        }
    }
}

练习题

  1. 主线程每隔1s，输出hi，一共10次

  1. 当输出hi 5时，启动一个子线程(要求实现Runnable)，每隔1s输出hello，等该线程输出10次hello后，退出

  1. 主线程继续输出hi，直到主线程退出

package com17.method;

/**
 * @author 甲柒
 * @version 1.0
 * @title ThreadMethod03
 * @package com17.method
 * @time 2023/3/28 23:22
 */
public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
            if (i == 5) {
                System.out.println("主线程 让 子线程");
                //join 线程插队
                T3 t3 = new T3();
                t3.start();
                t3.join();//相当于让t2线程先执行完毕
//                Thread.yield();//礼让 不一定成功
                System.out.println("子线程结束 主线程继续");
            }
        }
        System.out.println("主线程结束");
    }

}

class T3 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            try {
                Thread.sleep(1000);//休眠1s
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("hello " + i);
        }
    }
}

用户线程和守护线程

  1. 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束

  1. 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

  1. 常见的守护线程：垃圾回收机制

应用案例

测试如何将一个线程设置成守护线程

package com17.method;

/**
 * @author 甲柒
 * @version 1.0
 * @title ThreadMethod04
 * @package com17.method
 * @time 2023/3/29 14:22
 */
public class ThreadMethod04 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果希望当main线程结束后，子线程自动退出
        //只需将子线程设置为守护线程
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("iphone14ProMax 1TB 远峰蓝 被抢购...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    @Override
    public void run() {
        for (; ; ) {//等价于无线循环
            try {
                Thread.sleep(1000);//休眠1000ms
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("iphone14ProMax 1TB 远峰蓝~~~~");
        }
    }
}

线程的生命周期

JDK中用Thread.State枚举表示了线程的几种状态

线程状态转换图

写程序查看线程状态

package com17.state_;

/**
 * @author 甲柒
 * @version 1.0
 * @title ThreadState_
 * @package com17.state_
 * @time 2023/3/29 15:05
 */
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();
        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(500);
        }
        System.out.println(t.getName() + " 状态 " + t.getState());
    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            break;
        }
    }
}

猜你喜欢

转载自blog.csdn.net/qq_59621600/article/details/129676851
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022