多线程原理，实战

已于 2023-08-01 20:24:20 修改
阅读量181 收藏
点赞数
分类专栏： Java多线程 文章标签： java jvm 开发语言
于 2023-08-01 20:18:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57281267/article/details/132049923
版权

1.1 程序，进程，线程

  • 程序：完成一定功能的静态代码，对比火车站售票厅
  • 进程：正在执行的静态代码，称为进程，对比北京西站售票厅
  • 线程：并发执行一些异步任务，比对售票的中多个窗口
  • 单核cpu和多核cpu
  • java程启动后，main线程，gc线程，异常处理线程

1.2 并行和并发

  • 并行：多核cpu下，多线程同时执行
  • 并发：如果是单核cpu，采用抢占时cpu调度模型，让cpu在多个线程之间切换执行

完成一个任务需要多少个线程

  • io密集型 cpu核数*2
  • cpu密集型 cpu核数
  • 混合型 经验

1.3 线程使用的场景

  • 网络连接tomcat,mysql，一个连接对一个一个线程， one connection one thread
  • 文件操作，文件下载，后台启动一个线程异步执行长时间的任务

2 多线程实战

2.1 Thread方式实现多线程

  1. 定义子类继承Thread类。
  2. 类中重写Thread类中的run方法。
  3. 创建Thread子类对象，即创建了线程对象。
  4. 调用线程对象start方法：启动线程，调用run方法。

启动一个线程，在线程中执行1-10000的偶数打印工作

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 10000; i++) {
            if (i % 2 == 0) {
                //Thread.currentThread().getName()：得到线程的名字
                System.out.println(Thread.currentThread().getName() + "\t" + i);

            }
        }
    }
}

测试：

public class Test1 {

    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        myThread1.start();

        MyThread myThread2 = new MyThread();
        myThread2.start();

        System.out.println(Thread.currentThread().getName() + "  main 线程 over");

    }

}

//如果子线程执行，进程不会停止:

//弹窗挂起

 JOptionPane.showMessageDialog(null, "是否确认向下执行...."); //主线程进入IO阻塞
        System.out.println("main over");

2.2 Runable方式实现多线程

  • 定义子类，实现Runnable接口。
  • 类中重写Runnable接口中的run方法。
  • 通过Thread类含参构造器创建线程对象。
  • 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
  • 调用Thread类的start方法：开启线程， 调用Runnable子类接口的run方法。

public class ThreadDemo {

    public static void main(String[] args) {
        //方式1：Thread子类，启动
        MyThread thread1 = new MyThread();
        thread1.start();

        //方式2：Runable方式（推荐的方式）
        //优势：可以实现多继承，比如继承BaseDao，然后再实现Runnable
        MyTask task = new MyTask();
        Thread thread2 = new Thread(task);
        thread2.start();

        //方式3：匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 100; i++) {
                    System.out.println(Thread.currentThread().getName() +  "\t" +  i);
                }
            }
        }).start();
    }

}

//方式1
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() +  "\t" +  i);
        }
    }
}

//方式2
//优势：可以实现多继承，比如继承BaseDao，然后再实现Runnable
class MyTask implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() +  "\t" +  i);
        }
    }
}
 

2.3 Thread常见方法

  • 构造函数：
    • Thread()： 创建新的Thread对象
    • Thread(String threadname)： 创建线程并指定线程实例名
    • Thread(Runnable target)： 指定创建线程的目标对象，它实现了Runnable接口中的run方法
    • Thread(Runnable target, String name)： 创建新的Thread对象
  • void start(): 启动线程，并执行对象的run()方法
  • run(): 线程在被调度时执行的操作
  • String getName(): 返回线程的名称
  • void setName(String name):设置该线程名称
  • static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
  • static void yield()： 线程让步
    • 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
    • 若队列中没有同优先级的线程，忽略此方法
  • join() ： 当某个程序执行流中调用其他线程的 join() 方法时， 调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
  • static void sleep(long millis)： (指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
  • stop(): 强制线程生命期结束，不推荐使用
  • boolean isAlive()： 返回boolean，判断线程是否还活着

2.3 sleep

指定线程休眠的时间，单位毫秒，让出cpu时间片，其他线程可以抢占cpu时间片

public class MyTask implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                //Thread.currentThread().getName()：得到线程的名字
                System.out.println(Thread.currentThread().getName() + "\t" + i);
                try {
                    Thread.sleep(1000);
                    Thread.yield();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }

    }
}
 

2.4 线程优先级

  • 线程的优先级等级
    • MAX_PRIORITY： 10
    • MIN _PRIORITY： 1
    • NORM_PRIORITY： 5

    public static void main(String[] args) {
        MyTask myTask = new MyTask();
        Thread thread1 = new Thread(myTask, "t1");
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread1.start();

        Thread thread2 = new Thread(myTask, "t2");
        thread1.setPriority(Thread.MAX_PRIORITY);
        thread2.start();
    }

2.5 守护线程

  • 其他线程都执行结束，守护线程自动结束
  • 守护启动子线程，也是守护线程
  • 守护线程的语法thread.(setDaemon(true)设置守护线程

public class Test2 {

    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
//        myThread1.setDaemon(true);
        myThread1.start(); //守护线程， gc线程，jvm线程结束gc会自动结束
        JOptionPane.showMessageDialog(null, "是否确认向下执行...."); //主线程进入IO阻塞
        System.out.println("main over");
    }

}

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("a");
        }
    }
}
 

2.6 线程合并join

public class Test1 {

    /**
     * CountDownLatch：可以实现相同的效果
     * @param args
     */
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "\t" + i);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t1.start();

        try {
            t1.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        System.out.println(Thread.currentThread().getName() +  "  main orver");

    }

}
 

结果：

image.png

image.png

2.7 线程退出

2.7.1 stop

不推荐，线程退出方式粗暴，不管线程正在执行的任务，直接退出，可能丢失数据

public class Test1 {

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyTask());
        t1.start();

        Scanner in = new Scanner(System.in);
        System.out.println("输入1/0：0表示退出");
        int i = in.nextInt(); ///主线程进入IO阻塞

        if (i == 0) {
            t1.stop();
        }

        System.out.println("main over");
    }


    static class MyTask implements Runnable {

        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

}

2.7.2 中断信号interrupt

  • interrupt()：发送中断信号（true）
    • 如果线程在阻塞状态，比如sleep(),join(),wait()，这时接收到中断信号会抛出一个异常InterruptException，同时中断信号清除（false）
    • 只是发送信号，不会对线程产生影响
  • static interrupted（）：得到中断信号（true），然后把中断信号设置成false
  • isInterrupted()：得到中断信号，不会清除中断信号

public class Test1 {

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyTask());
        t1.start();

        JOptionPane.showMessageDialog(null, "是否确认向下执行...."); //主线程进入IO阻塞
        t1.interrupt(); //发送中断信号给t1

        System.out.println("main over");
    }

    static class MyTask implements Runnable {

        @Override
        public void run() {
            while (true) {
                System.out.println("a");

                try {
                    Thread.sleep(500000);
                } catch (InterruptedException e) {
                    System.out.println("bbbbbbbbbbbbbbb");
                    e.printStackTrace();
                    Thread.currentThread().interrupt(); //再次发送中断信号，中断信号发给阻塞线程，抛出Interrupt异常，中断信号清除
//                    throw new RuntimeException(e);
                }

                //得到中断信号，优雅的退出
                if (Thread.interrupted()) {
                    break;
                }

            }
        }
    }

}
 

高级的南松
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
多线程原理
fechinchu的博客
11-18 807
多线程原理多线程原理1.线程状态2.线程中止2.1.不正确的线程中止-stop2.2.正确的线程中止-interrupt2.3.正确的线程中止-标志位3.内存屏障和CPU缓存3.1.CPU性能优化手段-缓存3.1.1.缓存同步协议3.2.CPU性能优化手段-运行时指令重排3.3.引发的问题3.4.内存屏障4.线程通信4.1.通信方式4.1.1.文件共享4.1.2.变量共享4.1.3.线程协作-JDK API4.1.3.1.API-被弃用的suspend和resume4.1.3.2.API-wait/noti
多线程之jion原理
weixin_45970921的博客
02-28 187
join方法原理
java多线程使用详解与案例，超详细
热门推荐
languageStudent的博客
03-14 3万+
java多线程使用 java使用多线程的三种方式： 继承Thread类，并重写run方法。 实现Runnable接口，重写run方法 实现Callable<返回值>接口，重写call方法 实例如下 继承Thread class test extends Thread{ @Override public void run() { System.out.println("你好啊"); } } 开始启动线程： new test().start() 实现R
多线程实战
qq_42873640的博客
10-19 236
线程简介 实现一个线程，必须创建一个thread实例，override run方法，并且调用start方法启动线程。 线程的生命周期分为new，runnable，running，block，termate. 1. 创建线程的方式 newThread的方式创建线程 线程池 1.1 new Thread new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).s
多线程详解与实战
最新发布
zhichengcloub的博客
04-25 610
在Java中，多线程是一种重要的编程概念，它允许多个任务同时执行，从而提高程序的效率和响应速度。这对于需要处理大量数据、执行复杂计算或同时处理多个用户请求的应用程序来说非常有用。
多线程项目实战上篇
u010006156的博客
05-23 1521
前言 有了前2篇多线程和线程池基础铺垫后，简单介绍一下多线程在项目中最常见的应用场景。 一、多线程应用 1.项目中哪些业务场景会用到多线程？ 业务的并行处理和异步处理。 2. 如何在项目中使用多线程？ 并行处理的业务一般会通过Callable和Future创建线程； 异步处理的业务一般会使用@Async注解打在方法上，使得方法异步执行业务。 3. 本篇需要了解多线程和线程池的基础，不清楚的可以去看看我之前的博客： 多线程基础 线程池基础 二、并行业务 1.业务场景 业务 订单详细
C++多线程编程实践：从基础到实例的全面指南
BXA
05-10 6532
C++ 基础知识 九 线程和多线程一、线程基础知识1. 进程和线程的概念2. 多线程的优点和使用场景3. 线程的生命周期4. 线程的状态5. 线程的同步和互斥5.1 线程同步5.2 线程互斥6. 代码示例二、C++11线程库1 C++11线程库的概念和特性2 线程库中的关键类和函数3 使用线程库创建和控制线程4 使用线程库完成线程之间的同步和互斥5 原子变量和无锁数据结构的使用三、 多线程编程实践1 多线程程序的常见问题和调试技巧2 多线程程序的设计和实现方法3 多线程程序中的优化技巧4 异常处理和资源管理
Java并发编程系列8 - 多线程实战
开心博客
06-22 1156
【Java并发编程系列8】多线程实战
java多线程的讲解和实战
05-02
本资料详细讲解了Java多线程的原理，并提供了丰富的实战代码，非常适合Java初学者以及希望深入理解多线程的开发者。 1. **线程的基本概念**：线程是程序执行的最小单位，一个进程中可以有多个线程同时运行。Java...
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南...本书以基本概念、原理与方法为主线，辅以丰富的实战案例和生活化实例，并从Java虚拟机、操作系统和硬件多个层次与角度出发，循序渐进、系统地介绍Java平台下的多线程编程核心技术及相关工具。
C#多线程编程实战源码
08-23
通过《C#多线程编程实战源码》中的实例，你可以深入学习和实践上述知识点，理解多线程编程的原理和技巧，提高你的C#编程技能。同时，确保使用Visual Studio 2015进行开发，因为这些源码可能与此版本的编译器兼容。
多线程编程实战指南-核心篇
07-16
总之，《多线程编程实战指南-核心篇》是一本全面解析Java多线程编程的书籍，通过学习，开发者不仅可以掌握多线程编程的基本原理，还能学会如何在实际项目中应用这些知识，提升程序的并发性能和稳定性。对于有一定...
java多线程并发实战和源码
08-05
Java多线程并发实战与源码分析是Java开发中至关重要的一部分，它涉及到程序性能优化、系统资源高效利用以及复杂逻辑的正确同步。本书主要聚焦于Java多线程的基础理论和实际应用，虽然书中实例和源码相对较少，但仍然...
Python 多线程 Condition 的使用
danxibaoxxx的博客
10-24 1212
Python 多线程 Condition 的使用 Condition Condition（条件变量）通常与一个锁关联。需要在多个Contidion中共享一个锁时，可以传递一个Lock/RLock实例给构造方法，否则它将自己生成一个RLock实例。 可以认为，除了Lock带有的锁定池外，Condition还包含一个等待池，池中的线程处于状态图中的等待阻塞状态，直到另一个线程调用notify()...
JAVA多线程实战
超级氯化钾的博客
07-21 2406
是计算机中的程序关于某数据集合的一次运行活动，，一个线程就是进程中一个单一顺序的控制流，进程是线程的容器，一个进程至少有一个线程，一个进程可以有多个线程OS中是以进程为单位分配资源，如虚拟存储控件、文件描述符。每个线程都有自己的线程栈JVM启动时会自动创建一个主线程，该主线程负责执行main方法。主线程就是运行main方法的线程。.........
11.网络爬虫—多线程详讲与实战
weixin_50804299的博客
04-05 4945
程序 🧾 🧾程序是一系列指令或代码的集合，用于指导计算机执行特定的任务或操作。 程序可以是计算机程序、应用程序、脚本程序等，可以用不同的编程语言编写。程序通过计算机的处理和执行，实现了人类所需要的各种功能和应用。 进程 🧾 🧾进程是计算机中正在运行的程序的实例。 它是计算机为了完成某个任务而创建的一个执行单元，包含程序代码、数据和执行状态等信息。 每个进程都有自己的内存地址空间、文件句柄、网络连接等资源。 进程可以与其他进程进行通信和协作，也可以被操作系统调度和管理。 在多任务操作系统中，多个
多线程开发实战：Java实现多线程四种方式及相关方法原理
陈橘又青的博客
07-02 3万+
本文带大家了解Java实现多线程的四种方法以及实现多线程的重要注意事项和难点！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

高级的南松

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值