认识线程和创建线程

已于 2024-01-18 13:32:44 修改
阅读量1.1k 收藏 25
点赞数 28
分类专栏： javaEE 文章标签： java jvm 开发语言 面试 经验分享 其他
于 2023-12-09 17:39:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WHabc2002/article/details/134896671
版权

目录

1.认识多线程

1.1线程的概念

1.2进程和线程

1.2.1进程和线程用图描述关系

 1.2.2进程和线程的区别

1.3Java 的线程和操作系统线程的关系 

 2.创建线程

2.1继承 Thread 类

 2.2实现 Runnable 接口

 2.3匿名内部类创建 Thread 子类对象

2.4匿名内部类创建 Runnable 子类对象

2.5lambda 表达式创建 Runnable 子类对象 

1.认识多线程

1.1线程的概念

引入线程：进程虽然可以很好的实现并发编程，但在进行频繁的进程创建和销毁的过程中开销比较大（体现在资源的申请和释放上）。所以就发明了比进程更轻量的线程。

线程与进程相比：

（1）创建线程比创建进程更快 .
（2）销毁线程比销毁进程更快 .
（3）调度线程比调度进程更快 .
线程具体是什么？
  一个线程就是一个 " 执行流 ". 每个线程之间都可以按照顺序执行自己的代码 . 多个线程之间 " 同时 " 执行 着多份代码.

1.2进程和线程

1.2.1进程和线程用图描述关系
1.进程是包含线程的 . 每个进程至少有一个线程存在，即主线程。
2.进程和进程之间不共享内存空间 . 同一个进程的线程之间共享同一个内存空间 .
 1.2.2进程和线程的区别

（高频面试题）

1.进程是包含线程的。

2.每个线程就是一个 独立的"执行流"，可以单独执行一些代码，并参与到CPU的调度中（状态，上下文，优先级，记账信息，每个线程都有自己的一份）。

3.每个进程都有自己的资源，进程中的线程共用一份资源（内存空间和文件描述符表）。

（2）与（3）说明：

进程是系统分配资源的最小单位，线程是系统调度的最小单位。

4.进程与进程之间不会相会影响，但 线程与线程之间会相会影响。如果一个进程中的某个线程抛出异常，可能会导致进程中的所有线程都异常终止。

1.3Java 的线程和操作系统线程的关系 

1.线程是操作系统中的概念 . 操作系统内核实现了线程这样的机制 , 并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库 ).
2. Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装 .

注意：

（1）线程与线程之间可能会相互干扰，产生逻辑bug，引起线程安全。

（2）线程不是越多越好，线程太多调度开销可能会非常明显。

 2.创建线程

2.1继承 Thread 类

（1）继承 Thread 来创建一个线程类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("这里是线程运行的代码");
    }
}

此处 run()不需要手动调动，在线程创建好之后JVM会自动调用执行（回调函数）。

（2）创建 MyThread 类的实例

MyThread t = new MyThread();

创建出的实例才是真线程。 

 (3)调用 start 方法启动线程 

t.start(); // 线程开始运行

此时才会真正调用系统API，在系统内核中创建出线程（执行run())。

 为啥要在系统内核中创建出线程？

因为程序有时需要对软硬件资源进行操作。

完整示例：

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true){
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("MyThread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

 进程创建第一个线程时开销最大，之后的线程开销都比较小，但不是0，main线程其实是第一个线程。

一直循环…… 

 当有多个线程，它们的执行顺序是不确定的。

 使用 jconsole 命令观察线程

我们可以使用jdk自带的工具 jconsole查看当前Java进程中所有的线程

第一步，找到jdk

第二步，点进去，找到里面的bin文件点进去

第三步，在bin文件夹里搜索jconsole 

第四步，找到你所创建进程点击线程进行查看

 2.2实现 Runnable 接口

（1) 实现 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    public void run () {
        System . out . println ( " 这里是线程运行的代码 " );
  }
}

（2) 创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 参数.

Thread t = new Thread(new MyRunnable());

（3) 调用 start 方法

t.start(); // 线程开始运行 

 完整示例：

public class ThreadDemo2 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
        while(true){
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println("MyRunnable");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
这种写法其实就是把线程和要执行的任务进行了解耦合。
对比上面两种方法 :
1.继承 Thread 类 , 直接使用 this 就表示当前线程对象的引用 .
2.实现 Runnable 接口 , this 表示的是 MyRunnable 的引用 . 需要使用 Thread.currentThread()

 2.3匿名内部类创建 Thread 子类对象

// 使用匿名类创建 Thread 子类对象
Thread t1 = new Thread () {
    @Override
    public void run () {
        System . out . println ( " 使用匿名类创建 Thread 子类对象 " );
  }
};

  完整示例：

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t=new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("使用匿名类创建 Thread 子类对象");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start();
        while(true){
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

2.4匿名内部类创建 Runnable 子类对象

// 使用匿名类创建 Runnable 子类对象
Thread t2 = new Thread ( new Runnable () {
    @Override
    public void run () {
        System . out . println ( " 使用匿名类创建 Runnable 子类对象 " );
  }
});

  完整示例：

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("使用匿名类创建Runnable子类对象");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        while(true){
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

2.5lambda 表达式创建 Runnable 子类对象 

 lambda就是让方法看上去脱离类，单独存在。

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

  完整示例：

  public static void main(String[] args) {
        Thread t=new Thread(() -> {
            while(true){
                System.out.println("使用匿名类创建Runnable子类对象");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        while(true){
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

都看到这了，不如关注一下，给个免费的赞 

WH牛
关注
  • 28
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
线程的创建与实现
qq_41292216的博客
07-31 214
一、线程的创建与实现——线程库的使用 线程库包含在头文件pthread.h中 创建：int pthread_create(pthread_t *id,pthread_attr_t *attr,void *(*pthread_fun)(void*),void *arg); id:线程id，线程创建时分配的线程ID，传递一个变量的地址 attr：线程属性，默认为空 pthread_fun：线程...
认识线程及线程的创建方法（看完就懂）
gaoyu0914的博客
11-26 275
本篇文章介绍了线程的 3 ⼤类实现⽅式的7 种实现⽅法
Java 多线程（01）—— 认识线程和创建线程
2201_75456895的博客
05-27 1103
运行一个 Java 程序就是跑一个 Java 进程，该进程至少有一个线程即主线程，而 main 方法就是主线程的入口；
多线程的创建
遇安的博客
04-23 2659
创建方式一：继承Thread类创建多线程 public class 多线程_1创建 { public static void main(String[] args) { //创建方式一 Thread t=new MyThread();//创建MyThread线程对象 //直接调run()方法会被当成普通方法执行，此时相当于还是单线程执行， // 所以需要调用start()方法启动多线程 t.start();//调.
一篇文章认识4种Java多线程的创建方式
12-21
这是最基本的多线程创建方法。自定义一个类继承Thread类，然后重写run()方法。启动线程时，通过创建Thread类的子类实例并调用start()方法。这种方式限制了类的单继承性，因为Java不支持多重继承，所以如果类已继承...
IOS 创建并发线程的实例详解
08-29
如果没有为线程创建自动释放池，那些在新线程中创建的`autorelease`对象将不会被正确地释放，从而导致内存泄漏。 在`viewDidLoad`方法中，我们调用了`detachNewThreadSelector`两次，分别启动了`firstCounter`和`...
多线程】_认识多线程
12-19
1. 创建线程：在Java中，可以通过继承Thread类或实现Runnable接口来创建线程。前者直接继承Thread并重写run()方法，后者则创建一个实现了Runnable接口的类，然后在Thread对象中传递该实现类的实例。 2. 启动线程：...
线程的创建与撤销
04-18
对操作系统学习有帮助，可以对线程的认识更加深入
简单谈谈RxJava和多线程并发
08-31
总之，RxJava提供了强大的工具来处理异步和事件流，但开发者必须清楚地认识到并发和线程安全的挑战，并采取适当措施来避免潜在的问题。无论是选择线程安全的数据结构、使用`SerializedSubject`，还是巧妙地利用调度...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 791
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 872
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 997
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 809
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
接口防刷！利用redisson快速实现自定义限流注解
最新发布
架构师小吴的博客
07-18 786
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
【Java算法】前缀和 下
2302_79806056的博客
07-18 658
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 143
【JAVA】相关程序组件
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 696
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 502
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
操作系统实验31
08-08
操作系统实验31

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值