两步帮你搞定多线程之第一步

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量961 收藏 24
点赞数 35
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60202930/article/details/120627570
版权
本文深入探讨了Java中的多线程概念，通过实例代码展示了如何创建线程，包括继承Thread类、实现Runnable接口以及匿名类创建线程的方法。并详细解释了线程的抢占式执行特性，通过并发与串行执行的对比强调了多线程的效率优势。此外，还介绍了Thread类的常用属性，如线程ID、状态、优先级等。
摘要由CSDN通过智能技术生成

目录

导论：初识多线程

一：动手来创建多线程

1.1 创建一个主线程

1.2 多线程抢占式执行

二：创建线程的几个常用方法

2.2  继承 Thread 类

2.2 实现 Runnable 接口

2.3 匿名类创建

 三：Thread的几个常见属性

记：

导论：初识多线程

  首先，我们来讨论讨论什么叫做多线程。举个简单的例子，比如说造房子这个任务。如果只有一个人的话，他既要搬砖还得拎砂浆、搅拌水泥之类的（其他工种这里就不一一阐述了），哪怕这个工人技术再熟练，精力再旺盛，他同时也只能干一个工种。那么问题来了，该如何提升效率呢？很简单，我们可以请多个工人同时来干活，可以同时干多种也可以干同种活儿，这样效率就高得多。尽管他们各自可干着不同的活儿，但本质都是为了造房子这个任务，这就叫做多进程，即将一个大任务拆分成不同的小任务，分配不同的人来执行，当包工头也就是处理器下达命令时，他们按照指令来工作。

  每个工种的话，比如搅拌水泥的大工优惠叫来几个小工，都是来干搅拌水泥这个活儿，所以这里叫做多线程。

  那么，怎么区分多进程和多线程呢？这里简单概括：

进程是系统分配资源的最小单位，线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源的。
每个进程至少有一个线程存在，即主线程。

一：动手来创建多线程

1.1 创建一个主线程

请看代码：

public class ThreadDemo1 {
    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("hello world, 我是一个线程");
            while (true) {

            }
        }
    }

    public static void main(String[] args) {
        // 创建线程需要使用 Thread 类, 来创建一个 Thread 的实例.
        // 另一方面还需要给这个线程指定, 要执行哪些指令/代码.
        // 指定指令的方式有很多种方式, 此处先用一种简单的, 直接继承 Thread 类,
        // 重写 Thread 类中的 run 方法.

        // [注意!] 当 Thread 对象被创建出来的时候, 内核中并没有随之产生一个线程(PCB).
        Thread t = new MyThread();
        // 执行这个 start 方法, 才是真的创建出了一个线程.
        // 此时内核中才随之出现了一个 PCB, 这个 PCB 就会对应让 CPU 来执行该线程的代码. (上面的 run 方法中的逻辑)
        t.start();

        while (true) {
            // 这里啥都不干
        }
    }
}

接下里，我们可以通过jdk里面的一个jconsole来查看，我的文件路径是C:\Program Files\Java\jdk1.8.0_192\bin，大家可以对照自己安装的jdk文件位置来寻找。运行程序，打开jconsole可以看下

 这里这个主线程就是我们创建的线程，线程创建成功。

1.2 多线程抢占式执行

创建两个线程，输出线程运行前后时间，多次运行发现运行时间不一，这里就体现了现成的抢占式执行方法，看代码：

public class ThreadDemo2 {
    private static long count = 100_0000_0000L;

    public static void main(String[] args) {
        // serial();
        concurrency();
    }

    private static void serial() {
        long beg = System.currentTimeMillis();

        int a = 0;
        for (long i = 0; i < count; i++) {
            a++;
        }
        int b = 0;
        for (long i = 0; i < count; i++) {
            b++;
        }

        long end = System.currentTimeMillis();
        System.out.println("time: " + (end - beg) + " ms");
    }

    private static void concurrency() {
        long beg = System.currentTimeMillis();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                int a = 0;
                for (long i = 0; i < count; i++) {
                    a++;
                }
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                int b = 0;
                for (long i = 0; i < count; i++) {
                    b++;
                }
            }
        };
        t1.start();
        t2.start();

        try {
            // 线程等待. 让主线程等待 t1 和 t2 执行结束, 然后再继续往下执行.
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // t1 t2 和 main 线程之间都是并发执行的.
        // 调用了 t1.start 和 t2.start 之后, 两个新线程正在紧锣密鼓的进行计算过程中,
        // 此时主线程仍然会继续执行, 下面的 end 就随之被计算了.
        // 正确的做法应该是要保证 t1 和 t2 都计算完毕, 再来计算这个 end 的时间戳.
        long end = System.currentTimeMillis();
        System.out.println("time: " + (end - beg) + " ms");
    }
}

多次运行，会有以下结果：

 

 可以发现线程是抢占式执行。

我们用join关键字，可以规定线程运行先后顺序，比如这里规定t1运行完后t2再运行，代码如下：

public class ThreadDemo2 {
    private static long count = 100_0000_0000L;

    public static void main(String[] args) {
         serial();
        //concurrency();
    }

    private static void serial() {
        long beg = System.currentTimeMillis();

        int a = 0;
        for (long i = 0; i < count; i++) {
            a++;
        }
        int b = 0;
        for (long i = 0; i < count; i++) {
            b++;
        }

        long end = System.currentTimeMillis();
        System.out.println("time: " + (end - beg) + " ms");
    }

    private static void concurrency() {
        long beg = System.currentTimeMillis();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                int a = 0;
                for (long i = 0; i < count; i++) {
                    a++;
                }
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                int b = 0;
                for (long i = 0; i < count; i++) {
                    b++;
                }
            }
        };
        t1.start();
        t2.start();

        try {
            // 线程等待. 让主线程等待 t1 和 t2 执行结束, 然后再继续往下执行.
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // t1 t2 和 main 线程之间都是并发执行的.
        // 调用了 t1.start 和 t2.start 之后, 两个新线程正在紧锣密鼓的进行计算过程中,
        // 此时主线程仍然会继续执行, 下面的 end 就随之被计算了.
        // 正确的做法应该是要保证 t1 和 t2 都计算完毕, 再来计算这个 end 的时间戳.
        long end = System.currentTimeMillis();
        System.out.println("time: " + (end - beg) + " ms");
    }
}

 多次运行，结果如下：

 

 这里发现，由于规定了线程运行先后时间，导致运行时间大大增长，由此体现了线程并发运行的优势所在。

这里说明一点：由于线程是抢占式执行，所以每次结果都是不一定的，但误差会在一定范围内。

二：创建线程的几个常用方法

2.2  继承 Thread 类

可以通过继承 Thread 来创建一个线程类，该方法的好处是 this 代表的就是当前线程，不需要通过
Thread.currentThread() 来获取当前线程的引用。
class MyThread extends Thread {
@Override
public void run () {
System . out . println ( " 这里是线程运行的代码 " );
}
}
MyThread t = new MyThread ();
t . start (); // 线程开始运行

2.2 实现 Runnable 接口

通过实现 Runnable 接口，并且调用 Thread 的构造方法时将 Runnable 对象作为 target 参数传入来创建线程对象。
该方法的好处是可以规避类的单继承的限制；但需要通过 Thread.currentThread() 来获取当前线程的引用。
class MyRunnable implements Runnable {
@Override
public void run () {
System . out . println ( Thread . currentThread (). getName () + " 这里是线程运行的代码 " );
}
}
Thread t = new Thread(new MyRunnable());
t.start(); // 线程开始运行

2.3 匿名类创建

// 使用匿名类创建 Thread 子类对象
Thread t1 = new Thread() {
@Override
public void run() {
System.out.println(" 使用匿名类创建 Thread 子类对象 ");
}
};
// 使用匿名类创建 Runnable 子类对象
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(" 使用匿名类创建 Runnable 子类对象 ");
}
});
// 使用 lambda 表达式创建 Runnable 子类对象
Thread t3 = new Thread(() -> System.out.println(" 使用匿名类创建 Thread 子类对象 "));
Thread t4 = new Thread(() -> {
System.out.println(" 使用匿名类创建 Thread 子类对象 ");
});

 

 

 三：Thread的几个常见属性

 代码如下：

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ": 我还活着");
                    Thread.sleep(1 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + ": 我即将死去");
        });
        thread.start();
        System.out.println(Thread.currentThread().getName()
                + ": ID: " + thread.getId());
        System.out.println(Thread.currentThread().getName()
                + ": 名称: " + thread.getName());
        System.out.println(Thread.currentThread().getName()
                + ": 状态: " + thread.getState());
        System.out.println(Thread.currentThread().getName()
                + ": 优先级: " + thread.getPriority());
        System.out.println(Thread.currentThread().getName()
                + ": 后台线程: " + thread.isDaemon());
        System.out.println(Thread.currentThread().getName()
                + ": 活着: " + thread.isAlive());
        System.out.println(Thread.currentThread().getName()
                + ": 被中断: " + thread.isInterrupted());

        while (thread.isAlive()) {}
        System.out.println(Thread.currentThread().getName()
                + ": 状态: " + thread.getState());
    }
}

运行结果：

 由此可见各个关键字的含义，今天的分享就到这里。

记：

最近刚开学，各种事儿，选导师，研一七天都有课，导致时间紧张，希望自己还是可以平衡好学业和代码的关系吧，谢谢大家支持。

整理不易，大家多多支持。

爱敲代码的小高
关注
专栏目录
Redis——Current-limiting的原理与应用
庄小焱
03-15 852
摘要 限流算法在分布式领域是一个经常被提起的话题，当系统的处理能力有限时，如何阻止计划外的请求继续对系统施压，这是一个需要重视的问题。在这里用 “断尾求生” 形容限流背后的思想，当然还有很多成语也表达了类似的意思，如弃卒保车、壮士断腕等等。除了控制流量，限流还有一个应用目的是用于控制用户行为，避免垃圾请求。如在UGC 社区，用户的发帖、回复、点赞等行为都要严格受控，一般要严格限定某行为在规定时间内允许的次数，超过次数那就是非法行为。对非法行为，业务必须规定适当的惩处策略。 如何使用 Redis 来实现简
11.操作系统实战——第一个C函数，hal层初始化，初始化平台，
strive for the best 的博客
11-02 664
切换CPU到长模式 在调用第一个c函数之前，我们仍然要写一段汇编，切换CPU进入长模式，初始化CPU寄存器和C语言要用的栈。 因为目前代码执行流在二级引导器中，进入到 Cosmos 中这样在二级引导器中初始过的东西都不能用了 因为 CPU 进入了长模式，寄存器的位宽都变了，所以需要重新初始化。让我们一起来写这段汇编代码吧，我们先在 Cosmos/hal/x86/ 下建立一个 init_entry.asm 文件，写上后面这段代码 [section .start.text] [BITS 32] _start:
线程池简述
qudehu的博客
04-08 132
线程池 合理使用线程池的好处 java的线程是运用场景最多的并发框架，几乎所有需要异步或者并发执行任务的程序都可以使用线程池 合理使用线程池带来的好处 降低资源的消耗 通过重复利用已经创建的线程，降低频繁的创建与销毁线程所带来的资源消耗，例如Worker进程会无限循环从阻塞队列中获取任务执行 提高响应速度 当任务到达时，不需要等到线程创建就可以直接去使用 提高线程的可管理型 线程属于稀缺性资源，线程池可以对线程资源进行统一的调配，优化和监控 线程池的工作流程 一个新的任务到达线程池时，线程池的处理流程如下：
多线程初阶（一）
小小太空人的博客
11-30 544
上篇文章讲解了并发和并行的区别，目的就是将硬件资源得到充分利用。线程实际在操作系统内核中调度是抢占式调度，随机执行的。每个线程在cpu里执行时，都是以指令的方式去执行一个线程的，一个线程会包含多条指令。
多线程基础(中)
余音的博客
03-27 114
线程的状态 线程的所有状态 NEW: 安排了工作, 还未开始行动 Thread对象创建好了,但是没有调用start t.getState() 通过这个方法可以获取到当前线程的状态. 通过t这个对象调用的getState,就是获取到t的状态 TERMINATED: 工作完成了. 操作系统中的线程已经执行完毕,销毁了,但是Thread对象还在,获取到的状态 RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作. 就绪状态,处于这个状态的线程就是处于就绪队列中,随时可以被调度到C
多线程问题（二）（安全问题）
m0_62404808的博客
12-25 521
出现上述情况导致的结果就是更新丢失，例如是自增操作： 假设内存中的变量的初始值为0，t1就先把0加载到寄存器，但是t2进行抢占，也从内存中把0加载到寄存器然后自增为1，然后将1加载回内存，然后t1再自增为1，再将1加载回内存，按道理两次自增应该为2，但是由于线程的抢占以及自增操作是非原子的就会出现上述情况。线程的抢占式执行就是在一个线程的执行过程中，另一个更优先的进程会抢占当前线程执行的任务，当前线程就会被迫中断，这是引发线程不安全的根本原因，但是线程的调度是随机的，这是由系统决定的，我们无法改变。
多线程的线程安全
m0_60354608的博客
10-16 2329
wait notify是 用来控制多线程直接的执行先后顺序的wait 和 notify 都要先进行上锁(synchronized)必须是同一个对象调用wait 和 notify锁对象也要和 调用wait / notify 的对象一致就算没有wait , 直接notify 也是没有副作用的。
【干货知识】Redis：从应用到底层，一文帮你搞定
Linuxhus的博客
06-21 727
用途：底层：C语言中String用char[]数组表示，源码中用SDS(simple dynamic string)封装char[]，这是是Redis存储的最小单元，一个SDS最大可以存储512M信息。 Redis对SDS再次封装生成了RedisObject，核心有两个作用：说明是5种类型哪一种。里面有指针用来指向 SDS。当你执行set name sowhat的时候，其实Redis会创建两个RedisObject对象，键的RedisObject 和 值的RedisOjbect 其中它们type = R
一个程序员的日常书单(更新于2018/10/7)
Floating Cat
02-11 2万+
今日元宵节,祝各位节日快乐.本想谈谈读书这个话题,想来想起觉得无从下手,就此作罢.毕业这几年,一直不敢放松,在现代这个互联网时代更加认同萧抡谓的”一日不读书,胸臆无佳想;一月不读书,耳目失清爽”.如果非要给自己找个读书的理由的话,这句诗就是最好的理由:”胸藏文墨虚若骨,腹有诗书气自华”.
【Redis】高性能设计之epoll和IO多路复用深度解析
qq_43478625的博客
12-07 1512
文章目录一、Redis为什么快?高性能设计之epoll和IO多路复用深度解析1.1 Redis单线程如何处理那么多并发客户端连接，为什么单线程，为什么快?1.2 《Redis设计与实现》1.3 是什么?1.4 重要概念article同步异步同步与异步的理解阻塞非阻塞阻塞与非阻塞的理解总结1.5 Unix网络编程中的五种IO模型1.6 BIOjava验证演示acceptcode演示read案例1存在的问题案例2存在的问题1.7 NIO总结回答code案例存在问题和优缺点1.8 IO Multiplexing（
线程的调度有抢占式或者非抢占
飞翔的大象
08-28 2035
在一个进程里,线程的调度有抢占式或者非抢占的模式。 在抢占模式下，操作系统负责分配ＣＰＵ时间给各个进程，一旦当前的进程使用完分配给自己的ＣＰＵ时间，操作系统将决定下一个占用ＣＰＵ时间的是哪一个线程。因此操作系统将定期的中断当前正在执行的线程，将ＣＰＵ分配给在等待队列的下一个线程。所以任何一个线程都不能独占ＣＰＵ。每个线程占用ＣＰＵ的时间取决于进程和操作系统。进程分配给每个线程的时间很短,以至于我
java多线程抢占资源_java多线程知识整理
weixin_35361243的博客
02-16 896
java多线程知识整理 本文不是入门篇,仅记录容易出错的知识点为什么需要多线程根本原因:同一段时间尽量做更多的事;充分发挥CPU的功能,避免浪费CPU资源;同一时间需要做不同的事;多线程的核心问题对同一个变量的读写,导致脏写(数据库事务概念);多个线程相互协作,如何通信,比如线程A依赖线程B的某个资源如果没有特别的控制和机制,多个线程对同一个变量的读写,容易造成中间结果相互覆盖的情形,类似于数据库...
start()方法和run()方法区别与多线程抢占式运行原理
永远热泪盈眶 坚持输出
07-17 734
目录start()与run()方法区别多线程抢占式运行原理 start()与run()方法区别 我们通过一个例子来进行总结，我们写一个利用Thread创建的简单的多线程例子，然后分别执行start()与run()方法，执行结果如下所示： /** * @author ：zjc * @ProjectName: execises * @Package: com.execises.zjc.controller.thread * @ClassName: ThreadRunAndStartMethodCompa
抢占式任务调度和非抢占式（轮询任务调度）的区别，以及任务调度算法的用途。
热门推荐
u013176681的专栏
09-13 2万+
1、说说轮巡任务调度与抢占式任务调度的区别？ 答：轮询任务调度与抢占式任务调度的区别在于抢占式调度可以因为优先级高的任务抢占cpu，而轮询的不能。 2当软件线程个数超过硬件线程个数的时候，支持抢占式多任务处理的操作系统一般会采用时间片轮转调度的方案。 3 对于RTOS中，理解这两个概念是很重要的。实时系统对于响应时间是有非常严格的要求，尤其是在硬实时系统中，没有满足响应时间的上限将视为系统
java线程抢占式执行,Java并发基础(一)-线程基础
weixin_32866237的博客
03-12 688
原标题：Java并发基础(一)-线程基础 只要涉及到线程，其运行结果就是不确定的，虽然说java很早就提供了线程以及并发的支持，但是我们需要知道，线程是完全交给调度器的。有很多同学在编写书上的代码时，会发现运行结果不一致，其实这不是书上的例子错了，而是运行环境不一致导致的(cpu核数).而接下来的所涉及到到线程，指的是语言层次的线程，而不是操作系统层次的。1. Java语言中线程的实现从JDK 1...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 495
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 991
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 568
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 352
默认对常规Session的理解和使用，如何使用Set-Cookie。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论 37
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱敲代码的小高

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

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

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

打赏作者

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

抵扣说明：

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

余额充值