线程初级概述及代码应用

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量62 收藏
点赞数
分类专栏： 线程 文章标签： java 多线程 多进程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45314480/article/details/116563928
版权

线程

1、概述：

  • 进程：

    操作系统中一个程序及其数据在处理机上顺序执行时所发生的活动（是一个程序）

  • 线程：

    也是轻量级进程，是进程中某个单一顺序的控制流，一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。

  • 多进程

    在操作系统中同时运行多个任务(程序)

  • 多线程

    在同一应用程序中有多个顺序流同时执行

  • 线程的生命周期

    1.新建状态：创建出线程对象，线程处于新建状态
    2.就绪状态：线程调用start方法，当前线程会处于就绪状态，处于就绪状态的线程拥有争夺CPU资源的使用权力
    3.运行状态：如果当前线程争夺到CPU使用权，那该线程进入run方法，进入run方法的线程处于运行状态
    4.阻塞状态：处于运行状态的线程，如果发生了睡眠或者是控制台打印等需要发生等待的操作，该线程就处于阻塞状态，处于阻塞状态的线程会释放CPU的使用权
    5.死亡状态：run方法执行结束，当前线程任务完成，该线程处于死亡状态

2、创建线程

  • 注意：

         在Java中的多线程包含：主线程、普通线程、守护线程
      主线程：指的就是main函数，直接由jvm调用
      普通线程：自定义的线程就是普通线程
      守护线程：守护线程可以自定义，但是在Java中有默认的守护线程，例如：垃圾回收线程

实现Runnable接口

package com.itguo.thread;


/**
 * 实现线程的方式
 *      实现Runnable接口
 *      这种方式也是我们常使用的方式，因为我们以后会面向接口开发
 */

public class ThreadTest02 {

    public static void main(String[] args) {

        //这是一个可以运行的对象，而不是线程对象
        MyThread01 myThread01 = new MyThread01();

        //创建线程对象 ,通过构造将myThread01传进去
        Thread thread = new Thread(myThread01);

        //设置线路名称
        thread.setName("t1");

        //启动线程
        thread.start();



        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);

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

        }

    }

}


class MyThread01 implements Runnable{

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);

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


        }

    }
}

继承Thread类

package com.itguo.thread;

/**
 * 实现线程的方式：
 * 继承Thread
 * ThreadImpl extends Tread{
 *     run(){
 *
 *     }
 * }
 */
public class ThreadTest01 {

     public static void main(String[] args) {

        //创建线程对象
        ThreadImpl thread = new ThreadImpl();
        //启动线程
        thread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程"+i);
        }

    }

}
class ThreadImpl extends Thread{

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println("自定义线程"+i);
        }

    }
}
  • 输出结果：
主线程0
自定义线程0
自定义线程1
主线程1
主线程2
主线程3
自定义线程2
自定义线程3
自定义线程4
自定义线程5
自定义线程6
自定义线程7
自定义线程8
自定义线程9
主线程4
主线程5
主线程6
主线程7
主线程8
主线程9
  • 注意：主线程和自定义线程是并发执行的状态，同时去争夺CPU资源的使用权

线程常用方法简单使用：

package com.itguo.thread;

/**
 * 实现线程的第一种方式：
 * 继承Thread
 * ThreadImpl extends Tread{
 *     run(){
 *
 *     }
 * }
 *      在Java中的多线程包含：主线程、普通线程、守护线程
 *      主线程：指的就是main函数，直接由jvm调用
 *      普通线程：自定义的线程就是普通线程
 *      守护线程：守护线程可以自定义，但是在Java中有默认的守护线程，例如：垃圾回收线程
 *
 * @author ShuaiGUO
 */
public class ThreadTest01 {

    public static void main(String[] args) {

        //创建线程对象
        ThreadImpl thread1 = new ThreadImpl();
        ThreadImpl thread2= new ThreadImpl();
        ThreadImpl thread3 = new ThreadImpl();

        //设置线程名称
        thread1.setName("t1");
        thread2.setName("t2");
        thread3.setName("t3");

        //启动线程
        thread1.start();
        thread2.start();
        thread3.start();

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }

        try {
            //模拟睡眠
            Thread.sleep(500);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}
class ThreadImpl extends Thread{

    @Override
    public void run() {


        //获取当前线程对象Thread.currentThread()
        Thread thread = Thread.currentThread();

        //获取线程名称thread.getName()
        //System.out.println(Thread.getName());

        for (int i = 0; i < 10; i++) {
            System.out.println(thread.getName()+" "+i);


            try {
                //模拟睡眠
                Thread.sleep(500);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }
}
  • 输出结果：
main 0
main 1
main 2
main 3
main 4
main 5
main 6
main 7
main 8
main 9
t1 0
t2 0
t3 0
t1 1
t2 1
t3 1
t1 2
t2 2
t3 2
t3 3
t2 3
t1 3
t2 4
t3 4
t1 4
t3 5
t2 5
t1 5
t3 6
t2 6
t1 6
t1 7
t2 7
t3 7
t3 8
t1 8
t2 8
t2 9
t3 9
t1 9
  • join() 合并线程的方法；isAlive()方法线程是否处于存活状态；suspend()挂起线程；强制杀死线程stop()；唤醒线程resume()；唤醒正在睡眠的线程,利用了异常机制interrupt();
package com.itguo.thread;

//join 合并线程的方法，指定线程进入长期阻塞状态，直到剩余线程进入死亡状态，该线程才执行！！！
public class ThreadTest08 {

    public static void main(String[] args) {


        //创建线程对象
        Thread t1 = new Thread(new CreateThread03());
        //Thread t2 = new Thread(new CreateThread03());

        //线程名称
        t1.setName("t1");
        //t2.setName("t2");


        //开启线程
        t1.start();
        //t2.start();

        System.out.println("t1线程是否处于存活状态 "+t1.isAlive());

        for (int i = 0; i <= 10; i++) {

        /*    if (i == 5){

                try {
                    //合并线程
                    t1.join();

                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }*/

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

            //模拟睡眠
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

        //唤醒正在睡眠的t1线程,利用了异常机制
        t1.interrupt();

        //唤醒t1线程
        //t1.resume();


    }


}

class CreateThread03 implements Runnable {

    @Override
    public void run() {

        //模拟睡眠一小时
        try {
            Thread.sleep(1000 * 60 * 60);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i <= 10; i++) {

          /*  if (i == 5){

                //线程自己把自己挂起（处于阻塞状态）
                Thread.currentThread().suspend();

            }*/
        /*    if (i == 7){

                //强制杀死线程
                Thread.currentThread().stop();
            }*/

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


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

        }


    }


}

线程的生命周期java代码解释

package com.itguo.thread;
/**
 * 线程的生命周期
 * 1.新建状态：创建出线程对象，线程处于新建状态
 * 2.就绪状态：线程调用start方法，当前线程会处于就绪状态，处于就绪状态的线程拥有争夺CPU资源的使用权力
 * 3.运行状态：如果当前线程争夺到CPU使用权，那该线程进入run方法，进入run方法的线程处于运行状态
 * 4.阻塞状态：处于运行状态的线程，如果发生了睡眠或者是控制台打印等需要发生等待的操作，该线程就处于阻塞状态，处于阻塞状态的线程会释放CPU的使用权
 * 5.死亡状态：run方法执行结束，当前线程任务完成，该线程处于死亡状态
 */

public class ThreadTest03 {

    public static void main(String[] args) {

        //这是一个可以运行的对象，而不是线程对象
        MyThread02 myThread02 = new MyThread02();

        //创建线程对象 ,当前线程处于新建状态
        Thread thread = new Thread(myThread02);

        //设置线路名称
        thread.setName("t1");

        //启动线程，线程处于就绪状态，处于就绪状态的线程拥有争夺CPU资源的使用权力
        thread.start();



        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);

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

        }

    }

}


class MyThread02 implements Runnable{

    @Override
    public void run() {//进入run方法的线程处于运行状态

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);

            //当前线程睡眠会处于阻塞状态，处于阻塞状态的线程会释放CPU使用权
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }

    }

    //当run方法结束之后，线程处于死亡状态

}

匿名内部类创建线程对象

package com.itguo.thread;

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

        //创建线程对象
        Thread thread = new Thread(new Runnable() {


            @Override
            public void run() {

                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+" "+i);

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

                }
            }


        });

        //启动线程对象
        thread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);

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

        }
    }


    }

输出结果

main 0
Thread-0 0
Thread-0 1
main 1
Thread-0 2
main 2
Thread-0 3
main 3
Thread-0 4
main 4
Thread-0 5
main 5
Thread-0 6
main 6
Thread-0 7
main 7
Thread-0 8
main 8
Thread-0 9
main 9

3、多线程在jvm上的分布

1.在java的多线程种，一个线程对应一个栈

2.栈中的资源是线程不共享的

3.堆和方法区中的资源是线程共享的

JVM：

​ 栈：局部变量的声明

​ creatThread t1

​ creatThread t2

​ creatThread t3

​ 堆：成员变量，和new出来的部分

​ new creatThread();
​ new creatThread();
​ new creatThread();

​ 方法区：字节码，常量池

​ CreateThread.class

​ ThreadTest.class

4、线程调度模型

  1. 抢占式调度模型（java使用）
  2. 均分式调度模型
管不住嘴的要吃喝
关注
专栏目录
多线程初级
liang22471的博客
06-20 67
文章目录单线程多线程1、线程概述1.1进程1.2线程2、线程创建2.1Thread类实现多线程 单线程 在JavaSE中学习的程序，基本都是单线程的，也就是程序从main()方法进入之后按照顺序执行，如果程序中的某一个地方出现问题，那么整个程序就会出现问题，参考一下JavaSE中的运行时异常，如果没有经过处理，那么程序会崩溃。这就足以说明单线程程序是比较脆弱以及有相对的局限，这也就是单线程的脆弱性和局限性 当然也可以把单线程看成一个队列，程序每要执行一个线程，就相当于入队，也就是按照顺序，直到执行完成。 多
Python Django 5 Web应用开发实战
热门推荐
weixin_43178406的博客
05-21 2万+
本文主要介绍了Python Django 5 Web应用开发实战，希望能对学习Python Web应用开发的同学们有所帮助。 文章目录 1. 前言 2. 书籍推荐 2.1 内容简介 2.2 本书作者 2.3 本书目录 2.4 适合读者 3. 购买链接
C++标准库笔记-多线程概述
黑山老妖的博客
05-15 295
关于并发 现代化体系结构通常支持同时执行多个任务(task)和多个线程(thread)。 如果采用多线程处理器，程序执行时间可以在多线程情况下获得大幅度改善。 程序员在刚开始进行程序编写时，一般都是编写单线程的程序。程序从开始执行到执行结束，只是用一个主线程，不考虑怎么最大化的榨干CPU处理器的性能，这里更谈不上对GPU计算资源的使用了。 在《Java并发编程实战》的第一句话就是“编写正确的程序很难，而编写正确的并发程序则难上加难”；由此可见写好可以正常正确执行的并发程序是多么不容易；既然并发程序这么难写，
110道Java初级面试题及答案（最新Java初级面试题大汇总）
架构师专栏
11-08 2万+
史上最全Java初中级面试题，发现网上很多Java初级面试题都没有答案，所以花了很长时间搜集整理出来了这套Java面试题大全，希望对大家有帮助哈~ 本人发现网上虽然有不少Java相关的面试题，但第一未必全，第二未必有答案，第三虽然有答案，但未必能在面试中说，所以在本文里，会不断收集各种面试题，并站在面试官的立场上，给出我自己的答案。 如果不背 Java面试题的答案，肯定面试会挂！ 这套Java面试题大全，希望对大家有帮助哈~ 博主已将以下这些面试题整理成了一个Java面试手册，是PDF版的 1、为
进行线程模型概述
记录点滴的专栏
10-09 274
一．进程基本概念 1.多道程序设计是允许多个程序同时进入内存并运行，其目的是为了提高系统效率。 2.并发环境：一段时间间隔内，单处理器上有两个或两个以上的程序同时处于开始运行但尚未结束的状态，并且次序不是事先确定的。 在并发环境中执行的程序叫做并发程序。          3.进程的定义：（进程又称作CPU的抽象）          进程是具有独立功能的程序关于某个数据集合上的一次运行活
Java基础知识及应用
fyr6103032003的博客
03-04 2454
将Java入门的基础知识进行了一定总结，适用于学习过，但需要复习和加固基础的人群查阅
线程之初级篇
weixin_30339457的博客
10-24 49
写在前面的话：此文只能说是java多线程的一个入门，其实Java里头线程完全可以写一本书了，但是如果最基本的你都学掌握好，又怎么能更上一个台阶呢？ 　　本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。在这之前，首先让我们来了解下在操作系统中进程和线程的区别： 　　进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切...
JAVA 线程 之 初级线程安全
worm
05-09 379
第一part: 概述 首先介绍一些基本概念：程序、进程、线程的概念 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。                           如：运行中的QQ，运行中的MP3播放器，程
C++发展概述、优缺点及应用领域
小白的逆袭
08-06 3663
个人观点（C++虽功能强大，但是底层还是调用C,C++为了吸引更多的C程序员，功能过于丰富且复杂，一定程度上反而降低了可编程的实用性。但是不可否认C++ 也是一门艺术。） C++是一门以C为基础发展而来的一门面向对象的高级程序设计语言，从1983年由Bjarne Stroustrup教授在贝尔实验室创立开始至今，已有30多个年头。C++从最初的C with class，经历了从C++98、C+...
线程（初级）.docx
12-30
#### 一、线程概述 线程是计算机程序中的最小运行单元，它是在操作系统中能够独立调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存空间），但每个线程有自己的执行栈和程序计数器...
《Android应用开发揭秘》附带光盘代码.
09-30
《Android应用开发揭秘》全部实例源代码，配合《Android应用开发揭秘》使用 前言 　第一部分 准备篇 　第1章 Android开发简介 　1.1 Android基本概念 　1.1.1 Android简介 　1.1.2 Android的系统构架 　1.1.3 ...
JavaSE 初级部分第一周测试（java语言概述、java基本语法）
weixin_45801537的博客
11-24 1864
一、单选题 1. Java 语言是一种( ) 语言 。（选择一项） A．机器 B．汇编 C．面向过程的 D．面向对象的 解析：B D ; Java语言是一种面向对象的语言，与其他面向对象语言相比，Java利用面向对象技术更彻底，它把所有的Java应用和Applet都看作对象。 2.java 程序的执行过程中用到一套 JDK 工具，其中 javac.exe 指（ ）。（选择一项） A．java 语言...
工厂模式的介绍及实现
户伟伟的博客
09-25 101
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 229
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 846
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
智能BI平台项目
2302_79400545的博客
09-22 227
BI商业智能：数据可视化、报表可视化系统。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 724
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
y050505的博客
09-25 453
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值