多线程的初步认识

于 2024-08-08 17:32:40 发布
阅读量259 收藏 3
点赞数 14
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80706853/article/details/141027642
版权

 

目录

1、线程的概念

1.1 线程的注意事项

1.2 进程和线程的区别

2、线程的创建

2.1 继承Thread创建

2.2 实现Runnable创建

2.3 使用匿名内部类创建

2.4 使用lambda表达式

3、线程启动

4、线程终止

5、线程等待

 多线程是提升程序性能的一种非常重要的方式，使用多线程可以让程序充分利用CPU的资源，提高CPU的使用效率，从而解决高并发带来的负载均衡问题。

1、线程的概念

每个运行的程序都是一个进程，在一个进程中还可以有多个执行单元同时运行，这些执行单元就可以看作程序执行的一条条线索，称为线程。

操作系统中每一个进程中至少存在一个线程。

例如，当一个Java程序启动时，就会产生一个进程，该进程中会默认创建一个线程，在这个线程上会运行main()方法中的代码。

一个进程可以根据需要创建多个线程，从而实现”并发编程“的效果。

1.1 线程的注意事项

1、一个进程中是可以有多个线程的，每个线程都是可以独立进行调度的。

2、一个进程可以使用一个PCB表示，一个进程也可能使用多个PCB表示，每个PCB对应到每个线程上。

3、同一个进程的多个线程之间，共用一份内存空间和文件资源。

1.2 进程和线程的区别

1、进程包含线程，一个进程里面可以有多个线程。

2、进程和线程都是用来实现并发编程场景的，但是线程比进程更高效。

3、同一个进程的线程之间，共用一份的资源，省去了申请资源的开销。

4、进程和进程之间，具有独立性，不会相互影响。线程和线程之间，是可能会相互影响的。

5、进程是资源分配的基本单位，线程是调度执行的基本单位。

2、线程的创建

线程的创建主要有五种方式：

1、继承Thread，重写run

2、实现Runnable，重写run

3、继承Thread，重写run，使用匿名内部类

4、实现Runnable，重写run，使用匿名内部类

5、使用lambda

2.1 继承Thread创建

1、使用Thread这个类，可以创建Thread对象，进一步就可以创建操作系统内部的线程。

2、start和run都是Thread的成员，run只是描述了线程的入口（线程该做什么任务），start则是真正的调用了系统的API，在系统中创建了线程，再调用run。

3、在多线程中，main()方法和MyThread类的run()方法可以同时运行，互不影响。

4、可以使用sleep()方法来降低线程运行的速度。

class MyThread extends Thread{
    @Override
    public void run() {
        while (true) {

            System.out.println("hello Thread");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class demo {
    public static void main(String[] args) {
        Thread t=new MyThread();
        t.start();
        while (true){

            System.out.println("hello main");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

2.2 实现Runnable创建

通过继承Thread类实现多线程，具有一定的局限性。因为Java只支持单继承，一个类一旦继承了某个父类就无法再继承Thread类，就无法通过继承Thread类创建线程。

Thread类提供了另一个构造方法Thread(Runnable target),其中Runnable是一个接口，它只有run()方法。当通过Thread(Runnable target)构造方法创建线程对象时，只需要为该方法传递一个实现了Runnable接口的实例对象，就可以调用Runnable接口中的run()方法作为运行代码。

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while (true){

            System.out.println("hello Runnable");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class demo{
    public static void main(String[] args) {
        Runnable runnable=new MyRunnable();
        Thread t=new Thread(runnable);
        t.start();
        while (true) {

            System.out.println("hello main");

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

2.3 使用匿名内部类创建

使用匿名内部类创建就是将继承的Thread类和实现的Runnable类，写成一个匿名内部类，在一个类中创建。

继承Thread,重写run

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

        Thread t=new Thread(){

            public void run() {
                while (true) {
                    System.out.println("hello Thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

实现Runnable,重写run

public class demo{

    public static void main(String[] args) {

        Runnable runnable=new Runnable(){

            public void run() {
                while (true){
                    System.out.println("hello Runnable");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread t=new Thread(runnable);
        t.start();
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

2.4 使用lambda表达式

lambda表达式，本质上是一个匿名函数，主要实现”回调函数“的效果，让语法表达更加简化。

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

        Thread t=new Thread(()-> {

        while (true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        });

        t.start();

        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3、线程启动

public class demo {

    public static boolean isQuit=false;

    public static void main(String[] args) throws InterruptedException {

        Thread t=new Thread(()->{

           while (!isQuit){
               System.out.println("线程在工作中");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });

        t.start();

        Thread.sleep(5000);

        isQuit=true;

        System.out.println("线程工作结束");

    }

}

4、线程终止

Thread.currentThread()方法可以获取当前线程的实例

isInterrupted()方法调用Thread内部的标志位，根据这个标志位就可以判断线程是否结束

t.interrupt()方法把Thread对象内部的标准位设置为true

public class demo {
    public static void main(String[] args) throws InterruptedException {

        Thread t=new Thread(()->{

           while (!Thread.currentThread().isInterrupted()){

               System.out.println("线程工作中");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });

        t.start();
        Thread.sleep(1000);
        System.out.println("让t线程中止");

        t.interrupt();
    }

}

5、线程等待

让一个线程等待另一个线程执行结束，再继续执行，本质上就是控制线程的顺序。

在主线程中调用t.join()，就是让主线程等待t线程先结束。

public class demo {

    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(() -> {

            for (int i = 0; i < 5; i++) {
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();

        System.out.println("join等待开始");

        t.join();

        System.out.println("join等待结束");

    }

}

t.join()的工作原理

1、如果t线程正在运行中，此时调用join的线程就会堵塞，一直阻塞到t线程执行结束为止

2、如果t线程已经执行结束了，此时调用join的线程，就会直接返回，不会涉及到堵塞

xin-cyy
关注
  • 14
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程——初步认识线程
comerun的博客
07-14 584
在我一开始学习多线程的时候，一直很疑惑的是，为什么要创造多线程，线程又是什么？其实很多时候问题就藏在我们的生活当中，我们也可以把编程的思想与现实生活联系起来就可以理解为什么Java之父要去专门设计线程。
线程初步认识
H48530的博客
06-28 610
线程认识线程(Thread)概念什么情况下需要线程创建Java线程Thread的几个常见属性如何创建Java线程start() vs run()Thread类常见的构造方法：线程中断调用方法等待一个线程线程的状态Thread.isXXX()Thread中常见静态方法观察线程状态工具 认识线程(Thread) 概念 线程属于进程的组成（每个进程中至少有一个线程（主线程），也可以有多个线程） 线程是os进行调度的最小单位。 进程是系统分配资源（包括CPU）的最小单位，线程是系统调度（CPU分配）的最小单位
初步了解多线程
Ddoze的博客
07-20 231
一、线程与进程的认识与联系 在生活中，我们打开qq、微信啊这些应用程序就相当于开启了一个进程。而当我们用这些软件中的功能，比如：看朋友圈、聊天、扫一扫等操作的时候。这些就相当于是进程了。 1.简单来说，进程：指在系统中正在运行的一个应用程序；一个程序可以执行多个任务（也就是线程）。它占独立的空间，每个进程保持各自运行状态，相互之间不会干扰，是并发执行的（并发指按先后顺序执行）。程序一旦运行就是进程；进程——资源分配的最小单位。 线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。
【JavaEE】初步认识多线程
最新发布
2302_79806056的博客
08-08 634
下面是一些关于线程的关键点：控制流：线程是进程内单一顺序的控制流，每个线程有自己的执行栈和寄存器状态，但共享所属进程的资源，如内存空间、文件句柄和信号。资源共享：在同一进程中，多个线程共享相同的虚拟地址空间、全局变量和其他进程级别的资源，这使得线程间的通信和数据共享比进程间更加高效和简单。独立调度：线程是独立调度和分派的基本单位，这意味着它们可以被操作系统调度来利用CPU时间，从而实现并行或并发执行。类型：
Java多线程的初步认识
Yaphst的博客
05-18 365
在谈线程之前，我们至少应该了解下进程是什么，简单来说，进程就是正在运行的应用程序，每一个正在运行的应用程序就会对应一个进程。 那么线程，就是依赖于进程而存在的，一个进程可以开启多个线程，由一个对象所开启的所有线程使用的是同一份成员属性。 多线程的两种方案： 继承Thread类 实现Runable接口1.继承Thread类public class MyThre
01认识多线程及其使用
好小伙
05-19 99
引出 并发/高并发 简单来说，并发是指单位时间内能够同时处理的请求数。默认情况下Tomcat可以支持的最大请求数是 150，也就是同时支持150个并发。当超过这个并发数的时候，就会开始导致响应延迟，连接丢失等问 题。 影响并发的两个因素: 硬件: CPU,内存,磁盘 网络 软件 线程数量 JVM内存分配大小 网络通讯机制(BIO,NIO,AIO) 磁盘IO Java中的线程 public class ThreadTest extends Thread{ @Override publ
7. 初步认识线程同步
十三阿哥的博客
01-26 329
初步认识线程同步的含义，通过一个实际案例去更好的认识线程同步。
java中对多线程的了解_关于java的多线程的初步认识
weixin_30836221的博客
02-27 94
进程：正在进行中的程序(直译). 线程：就是进程中一个负责程序执行的控制单元(执行路径) 一个进程中可以多执行路径，称之为多线程。一个进程中至少要有一个线程。开启多个线程是为了同时运行多部分代码。每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。多线程好处：解决了多部分同时运行的问题。多线程的弊端：线程太多回到效率的降低。其实应用程序的执行都是cpu在做着快速的切换完成的。这个...
Java多线程:多线程的初步认识理解以及入门使用
PrinceOfTheDevils的博客
02-28 190
Java多线程一直是一个被广大程序员讨论的热门,之前我对java的线程问题一直自认为是认识的片面,模糊.由此,决定重新学习一下java的多线程,在这里,为自己的学习以及理解做一下记录.更多的也是希望能够得到大家的指正,能够帮到那些想学习的朋友那就更好啦. 首先要知道进程以及线程之间的区别: 进程:是一次程序的执行,是系统进行资源分配和调度的一个独立单位,如果感觉很抽象,那可以打开任务管理器,...
python多线程就这么简单
01-27
所以，这里力图用简单的例子，让你对多线程有个初步的认识。在好些年前的MS-DOS时代，操作系统处理问题都是单任务的，我想做听音乐和看电影两件事儿，那么一定要先排一下顺序。（好吧！我们不纠结在DOS时代是否有听...
理解python多线程（python多线程简明教程）
01-20
所以，这里力图用简单的例子，让你对多线程有个初步的认识。 单线程 　在好些年前的MS-DOS时代，操作系统处理问题都是单任务的，我想做听音乐和看电影两件事儿，那么一定要先排一下顺序。 （好吧！我们不纠结在DOS...
多线程编程的入门教程
03-13
### 多线程编程的入门教程 ...通过以上内容的学习，相信你已经对多线程编程有了初步的认识，并且了解到了如何使用Win32API来进行多线程编程。在实际开发中，合理利用多线程能够极大地提升程序的性能和用户体验。
Learning:这里是我在Java学习过程中的一些代码，其中包括：MOOC课浙江大学数据结构课后习题部分实现，Java多线程编程代码实现，Spring框架工作原理初步认识
05-11
写在前面这里记录着一个跨行菜鸟的成长路程，希望能从一只菜鸟开始，慢慢成长！:-) 如果您对我的努力...Part1 《Java多线程编程核心技术》相关代码实现Part2 《Spring3.x企业应用开发实战》相关代码实现至第6章Part3
Linux多线程服务端编程：使用muduo C 网络库
03-30
通过阅读《Linux多线程服务端编程：使用muduo C++网络库》样章，读者可以对muduo库有一个初步的认识，并开始掌握如何在实际项目中应用这些技术。全书可能还涵盖了更多高级主题，如分布式系统、负载均衡、故障恢复等...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 450
使用TCP协议支持与多个客户端同时通信。
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1016
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 213
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 128
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
初步认识ThreadLocal
09-13
ThreadLocal是Java中的一个类，用于在多线程环境下为每个线程提供独立的变量副本。每个线程内部都有一个ThreadLocal.ThreadLocalMap属性，通过这个属性来实现存储和访问线程独立的变量副本。 通过ThreadLocal的set()方法和get()方法，我们可以对这个线程独立的变量副本进行存值和取值操作。set()方法用于将一个值存入当前线程的ThreadLocalMap对象中，其中ThreadLocal对象作为key，值作为value。而get()方法用于从当前线程的ThreadLocalMap对象中获取对应的值。 具体来说，set()方法首先获取当前线程，然后通过getMap()方法获取当前线程的ThreadLocalMap对象。如果ThreadLocalMap对象存在，则将值存入Map中，以ThreadLocal对象作为key，值作为value。如果ThreadLocalMap对象不存在，则创建一个新的Map对象，并插入值。 总结来说，ThreadLocal是通过每个线程独立拥有的ThreadLocalMap对象来实现存储和访问线程独立的变量副本的。通过set()方法和get()方法，我们可以对ThreadLocal对象进行值的存取操作。这样，不同线程可以独立地使用ThreadLocal对象，并且互不干扰，保证了线程安全性和数据隔离性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值