[Java]-多线程(API,线程的多种创建方式)

最新推荐文章于 2022-02-19 14:03:57 发布
最新推荐文章于 2022-02-19 14:03:57 发布
阅读量128 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/renboyu010214/article/details/106896778
版权

本章思维导图

多线程概述（并发编程）

进程

程序是静止的，而运行中的程序就是进程

特征

  • 动态性：进程是运行中的程序，要动态的占用内存，CPU和网络等资源
  • 独立性：进程和进程之间是相互独立的，彼此有自己独立内存区域
  • 并发性：假如CPU是单核，同一时刻内存中只有一个进程在被执行，CPU会依时为每个进程服务，由于切换速度非常快，给我们的感觉就是这些进程在同时执行，这就是并发性
并行：

同一时刻同时有多个进程在执行（多核CPU）

线程

线程属于进程，一个进程可以包含多个线程，这就是多线程。（线程是进程中的一个独立执行单元）线程的创建开销相对于进程来说比较小，线程也支持并发性

作用

  • 提高程序效率，线程支持并发性，可以有更多机会得到CPU
  • 多线程可以解决很多业务模型
  • 大型高并发技术的核心技术

线程创建方式一：继承Thread类

代码实现

package ThreadTest;

/*
* 创建线程的方法一：
* 1. 直接定义类继承Thread
* 2. 重写run()方法
* 3. 创建线程对象
* 4. 调用线程对象的start()方法启动线程
*/


// 定义一个线程类继承Thread类
class MyThread extends Thread{
    //重写run()方法
    @Override
    public void run() {
        // 线程的执行方法
        for(int i=0;i<5;i++){
            System.out.println("子线程输出："+i);
        }
    }

}


public class ThreadDemo {
    // 这里可以把启动后的ThreadDemo当成一个进程
    // main方法是由主线程执行的，理解成main方法就是一个主线程

    public static void main(String[] args) {
        //创建线程对象
        Thread t=new MyThread();  //多态
        //调用start()方法启动线程
        t.start();  //此时一共存在两个线程，一个是main函数表示的主线程，另一个就是t表示的子线程

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

运行结果

主线程输出：0
主线程输出：1
子线程输出：0
主线程输出：2
子线程输出：1
主线程输出：3
子线程输出：2
主线程输出：4
子线程输出：3
子线程输出：4

可以看到多线程是并发的，两个线程之间的执行顺序是完全随机的，双方都不断争抢CPU执行，并且执行过程始终向前推进

继承Thread类的优点

  • 编码相对简单

继承Thread类的缺点

  • 自定义线程类继承了Thread类，导致无法再继承其他类，功能单一，不能继续拓展（单继承的局限性）

线程的注意事项

线程的启动必须调用start()方法

否则操作就会被当作普通类处理，按照代码顺序正常执行。
也就是说，如果直接调用自定义线程类的run方法，实际上就变成了普通类执行，此时只有一个主线程在运行

start()方法底层其实是给CPU注册当前线程，并且触发run()方法的执行

一般建议进程中先创建子线程，主线程的任务放在之后（否则程序按顺序执行，先接触到主线程内容，并没有发现后续的子线程启动，导致主线程必然先进行完，整个流程实际上仍然是顺序执行）

线程创建方式二：实现Runnable接口

  1. 创建一个线程任务类实现Runnable接口
  2. 重写run()方法
  3. 创建一个线程任务对象
  4. 将线程任务对象包装成线程对象
  5. 调用线程对象的start()方法启动线程

代码实现

package ThreadTest;

public class ThreadDemo4 {
    public static void main(String[] args) {
        //3. 创建"线程任务"对象(不是线程对象，只是执行线程任务的)
        Runnable target=new MyRunnable();
        //4. 把线程任务对象包装成线程对象
        //Thread t=new Thread(target);   单纯创建线程对象
        Thread t=new Thread(target,"TheFirstThread");  //利用线程任务创建线程对象的同时为线程命名
        //启动线程
        t.start();

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

    }

}


//1. 首先，创建线程任务类实现Runnable接口
class MyRunnable implements Runnable {

    //2. 重写run()方法
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}

方式二的匿名内部类写法（简化写法）

package ThreadTest;

public class ThreadDemo4 {
    public static void main(String[] args) {
        Runnable target=new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<5;i++){
                    System.out.println(Thread.currentThread().getName()+"==>"+i);
                }
            }
        };
        Thread t=new Thread(target,"TheFirstThread");  
        t.start();

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

方式二实现Runnable接口创建的优点

  • 线程任务类只是实现了Runnable接口，所以可以继续继承其他类，而且可以继续实现其他接口，避免了单继承的局限性
  • 同一个线程任务对象可以被包装成多个线程对象
  • 适合多个相同的程序代码的线程去共享同一个资源
  • 实现解耦操作，线程任务代码可以被多个线程共享，线程任务代码和线程独立
  • 线程池可以放入实现Runnable或Callable线程任务对象

方式二实现Runnable接口创建的缺点

  • 代码较为复杂
  • 继承的Runnable接口的run()方法没有返回值，不能直接得到线程执行的结果
注意：Thread类本身也实现了Runnable接口

线程创建方式三：实现Callable接口

  1. 定义一个线程任务类实现Callable接口，申明线程执行的结果类型
  2. 重写线程任务类的call方法，这个方法可以直接返回执行结果（解决了Runnable接口的缺点）
  3. 创建一个Callable的线程任务对象
  4. 把Callable的线程任务对象包装成一个未来任务对象
  5. 把未来任务对象包装成线程对象
  6. 调用现成的start()方法启动线程

代码实现：

package ThreadTest;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo5 {
    public static void main(String[] args) {
        //3. 创建Callable线程任务对象
        Callable<String> call=new MyCallable();
        //4. 把Callable任务对象包装成未来任务对象
        //未来任务对象：本质就是一个Runnaable对象（FutureTask继承自Runnable）
        //未来任务对象可以在线程执行完后得到线程执行结果
        FutureTask<String> task=new FutureTask<String>(call);
        //5. 把未来任务对象包装成线程对象
        Thread t=new Thread(task,"TheFirstThread");
        t.start();

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

        //6. 最后获取线程执行结果,如果线程没有结果，会让出CPU等待线程执行完毕再来取值
        try {
            String rs=task.get();  //获取call方法返回的结果（正常/异常）
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//1. 创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable<String>{
    //2. 重写线程任务类的call方法
    @Override
    public String call() throws Exception {
        // 计算1~20的和
        int sum=0;
        for(int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
            sum+=i;
        }
        return Thread.currentThread().getName()+"执行的结果是："+sum;
    }
}

运行结果

TheFirstThread==>0
main==>0
TheFirstThread==>1
main==>1
TheFirstThread==>2
main==>2
TheFirstThread==>3
main==>3
TheFirstThread==>4
main==>4
TheFirstThread==>5
main==>5
TheFirstThread==>6
main==>6
TheFirstThread==>7
main==>7
TheFirstThread==>8
main==>8
TheFirstThread==>9
main==>9
TheFirstThread==>10
main==>10
TheFirstThread==>11
main==>11
TheFirstThread==>12
main==>12
TheFirstThread==>13
main==>13
TheFirstThread==>14
main==>14
TheFirstThread==>15
main==>15
TheFirstThread==>16
main==>16
TheFirstThread==>17
main==>17
TheFirstThread==>18
main==>18
TheFirstThread==>19
main==>19
TheFirstThread执行的结果是：190

方法三，继承Callable接口优点

拥有方法二的全部优点，并且能够通过返回值了解线程是否正常运行，得到线程执行的结果

方法三，继承Callable接口缺点

编码复杂

线程常用API

package ThreadTest;

// 定义一个线程类继承Thread类
class MyThread2 extends Thread{
    //重写run()方法
    @Override
    public void run() {
        // 线程的执行方法
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+" : 子线程输出 ："+i);
        }
    }

}

public class ThreadDemo2 {

    // 进程中一共包括两个子线程t1,t2与一个主线程
    public static void main(String[] args) {
        //创建线程对象
        Thread t1=new MyThread2();

        t1.setName("TheFirstThread");   //为线程命名

        t1.start();

        System.out.println(t1.getName());  //获取子线程的名字

        Thread t2=new MyThread2();

        t2.setName("TheSecondThread");   //为线程命名

        t2.start();

        System.out.println(t2.getName());  //获取子线程的名字

        //获取主线程名称的方法
        //利用currentThread()方法，可以获取当前所在的线程的对象
        //（注意，这里说的是在哪个线程内部，而不是正在执行哪个线程，三个线程随机执行，但此时都在主线程内）
        Thread m =Thread.currentThread();
        m.setName("MainThread");
        System.out.println(m.getName());  //从而就可获取到主线程名称

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

运行结果

TheFirstThread
TheSecondThread
MainThread
MainThread ：0
TheSecondThread : 子线程输出 ：0
TheFirstThread : 子线程输出 ：0
TheSecondThread : 子线程输出 ：1
MainThread ：1
TheSecondThread : 子线程输出 ：2
TheFirstThread : 子线程输出 ：1
TheSecondThread : 子线程输出 ：3
MainThread ：2
TheSecondThread : 子线程输出 ：4
TheFirstThread : 子线程输出 ：2
TheFirstThread : 子线程输出 ：3
TheFirstThread : 子线程输出 ：4
MainThread ：3
MainThread ：4

线程休眠方法：sleep()

让当前线程休眠指定时间（毫秒）后继续执行

package ThreadTest;

// 定义一个线程类继承Thread类
class MyThread3 extends Thread{
    //重写run()方法
    @Override
    public void run() {
        // 线程的执行方法

        for(int i=0;i<5;i++){
            try {
                Thread.sleep(1000);  //使子进程休眠1000ms再运行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" : 子线程输出 ："+i);
        }

    }

}

public class ThreadDemo3 {

    public static void main(String[] args) {
        //创建线程对象
        Thread t1=new MyThread3();
        t1.start();

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

通过Thread类的含参构造器为线程命名

Thread t1=new MyThread("TheFirstThread");
// 需要重写自定义线程的方法（直接调用父类有参构造器即可）
public MyThread(String name){
    super(name); //调用父类有参构造器并初始化线程对象的名称
}
Ywrby
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javaAPI 多线程总结
意志的胜利
11-14 529
进程： 线程：
Java多线程-创建线程的多种方式
RIZZ_的博客
03-21 192
Java多线程_创建线程的多种方式 一、线程与进程 ​ 几乎所有的操作系统都支持进程的概念，所有运行中的任务都对应一个进程(Process)。当一个程序进入内存运行时，即变成一个进程。进程是处于运行中的程序，并且具有一定的独立功能，进程是系统进行资源调度的一个独立单位。 ​ 一般而言，进程包含三个特征：独立性、动态性、并发性。 ​ 一个程序运行后至少会有一个进程，一个进程可以包含多个线程，但至少要有个线程。 ​ 归纳起来就是说：操作系统可以同时执行多个任务，每个任务就是进程；进程可以同时执行多个任务，
JAVA多线程的创建和API
随笔
12-10 169
多线程的创建方式 创建Thread类：new Thread() 实现Runnable接口：Runnable 线程的生命周期 NEW RUNNABLE RUNNING BLOCKED TERMINATED NEW： 创建状态 使用new关键字创建的对象 RUNNABLE：可执行状态 具备执行的资格，但并没有真正的执行起来而是在等待CPU的调度 NEW状态通过start方法进入RUNNAB...
多线程API函数
11-15 1383
主要的多线程API 1、线程创建函数： int pthread_create (pthread_t * thread_id,__const pthread_attr_t * __attr, void *(*__start_routine) (void *),void*__restrict __arg); 2、获得父进程ID： pthread_t pthread_self (void)
API基础第九天
dyr_080508的博客
02-17 437
API基础第九天
WIN32多线程一 用WIN32 API创建和结束线程
cpongo5
02-22 187
Win32中，内核对象属于WINDOWS的，而不属于进程。进程对象、线程对象、文件对象、文件映射对象、事件对象、互斥量对象等都属于内核对象。WIN32中一般通过CreateXXXX来创建内核对象，返回一个内核对象的句柄，进程不能直接操作内核对象，只能通过该句柄来访问内核对象。内核对象有一个使用计数，一个进程的内核对象句柄表中引用了某个内核对象，该内核对象的使用计数就递增1，该进程调用CloseHa...
Java多线程-线程的生命周期
01-27
Java多线程中，线程的生命周期是编程中必须理解的重要概念。在JDK1.5之前，线程被划分为五个状态，分别是新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）。在JDK1.5及之后，线程的...
Java多线程ThreadAPI详细介绍
08-25
Java多线程ThreadAPI详细介绍 本资源详细介绍了Java多线程的ThreadAPI，通过示例代码对ThreadAPI的使用进行了详细的讲解，从Thread的构造方法到Thread的使用、ThreadGroup的使用等方面对ThreadAPI进行了详细的介绍...
【Java-API-多线程】(02) - 文件
10-09
文章附件；JAVA；多线程；Thread；
【Java-API-多线程】(01) - 文件
10-09
文章附件；JAVA；多线程；Thread；
java-multithreading:java-多线程
06-09
java-多线程java-多线程用于多线程的 Java 并发 API。
MFC 使用window API函数创建多线程的方法（小白专用）
四月天的博客
02-21 593
本文介绍了最简单上手的利用window API函数创建一个多线程显示当前系统时间的步骤，编译环境为VS2010. 文件 --&gt;新建项目，如下，新建项目名称为ThreadDemo，点击确定 得到MFC新项目创建向导界面，点击下一步，选择基于对话框，点击完成即可，如下图所示： 2. 得到最原始的基于对话框的界面，如下： 3. 删除中间的static Text，添加一个Edit Con...
java多线程的api_Java多线程：实现API接口创建线程方式详解
weixin_39721807的博客
02-15 270
先看例子：/**实现Runnable接口创建线程步骤：* 1、创建一个实现Runnable接口的类* 2、重写Runnable类中抽象的run()方法* 3、创建实现类的对象* 4、声明Thread类，同时将实现类对象作为参数传递* 5、用Thread类的对象调用start()*///例子：多线程售票(暂未安全同步)class MyThread implements Runnable{privat...
使用Runnable接口创建线程，很简单
weixin_47556601的博客
02-19 7424
大家好，今天分享.使用Runnable接口创建线程 首先Java创建线程可以通过三种方法： 即： 1.继承Thread类创建线程类（重点） 2.通过Runnable接口创建线程类（重点） 3.通过Callable接口（了解即可） 今天，使用Runnable接口创建线程。 步骤： 1.定义MyRunnable类实现.Runnable接口 2.创建run()方法，编写线程执行体 3.创建线程对象，调用start（）方法启动线程 package Demo01; public class Thread03
Java 多线程 并发编程
热门推荐
escaflone的专栏
08-28 17万+
一、多线程 1、操作系统有两个容易混淆的概念，进程和线程。 进程：一个计算机程序的运行实例，包含了需要执行的指令；有自己的独立地址空间，包含程序内容和数据；不同进程的地址空间是互相隔离的；进程拥有各种资源和状态信息，包括打开的文件、子进程和信号处理。 线程：表示程序的执行流程，是CPU调度执行的基本单位；线程有自己的程序计数器、寄存器、堆栈和帧。同一进程中的线程共用相同的地址空间，同时共享进
Java并发编程示例(五)：线程休眠与恢复
太多的虚幻
08-19 1万+
知其然按照下面所示步骤，来实现本节示例。1.创建一个名为FileClock的类，并且实现Runnable接口。代码如下：public class FileClock implements Runnable {2.实现run()方法。代码如下：@Overridepublic void run() {3.写一个遍历十次的循环，在每次迭代中，创建一个Date对象，并将其打印到控制台。然后，通过TimeUt
NexusSetup.exe是Nexus设备设置程序的执行文件
最新发布
06-25
这款Windows Dock栏工具解决了窗口遮挡问题，支持将窗口最小化至Dock栏，相比mydock稳定性更好，而相比bitdock体积更小，是一款适中的优秀选择，值得推荐。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
JAVA高质量并发详解,多线程并发深入讲解
04-24
书中详尽地介绍了Java并发编程的基础知识、API、高级特性以及设计模式，旨在帮助读者深入理解并掌握多线程编程，提升系统性能。" 在Java并发编程中，了解和熟练掌握相关组件和关键字至关重要。`java.util....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值