【Java】创建线程

已于 2024-07-25 12:07:09 修改
阅读量608 收藏 8
点赞数 17
分类专栏： Java 文章标签： java jvm 开发语言
于 2024-07-22 15:54:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiugongHao/article/details/140612174
版权

下面笔记来源尚硅谷，仅供学习。

基本流程

  1. 定义一个类,继承Thread
  2. 重写run方法,在run方法中设置线程任务(所谓的线程任务指的是此线程要干的具体的事儿,具体执行的代码)
  3. 创建自定义线程类的对象
  4. 调用自定义线程类对象中的start方法,开启线程,jvm自动调用run方法

方法一：继承类

public class Test01 {
    public static void main(String[] args) {
        //创建线程对象
        MyThread t1 = new MyThread();
        //调用start方法,开启线程,jvm自动调用run方法
        t1.start();

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

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("MyThread...执行了"+i);
        }
    }
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Thread 类中的方法

void start() -> 开启线程,jvm自动调用run方法

void run()  -> 设置线程任务,这个run方法是Thread重写的接口Runnable中的run方法

String getName()  -> 获取线程名字

void setName(String name) -> 给线程设置名字

static Thread currentThread() -> 获取正在执行的线程对象(此方法在哪个线程中使用,获取的就是哪个线程对象)   

static void sleep(long millis)->线程睡眠,超时后自动醒来继续执行,传递的是毫秒值 

void setPriority(int newPriority)   -> 设置线程优先级,优先级越高的线程,抢到CPU使用权的几率越大,但是不是每次都先抢到
    
int getPriority()  -> 获取线程优先级 默认为5 最小1 最大10
    
void setDaemon(boolean on) 
//设置为守护线程,当非守护线程执行完毕,守护线程就要结束
//但是守护线程也不是立马结束,会延迟一小段时间结束
    
static void yield() -> 礼让线程,让当前线程让出CPU使用权
   
void join() -> 插入线程或者叫做插队线程    

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //线程睡眠
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"...执行了"+i);
        }
    }
}


public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        //创建线程对象
        MyThread t1 = new MyThread();

        //给线程设置名字
        t1.setName("金莲");

        //调用start方法,开启线程,jvm自动调用run方法
        t1.start();

        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName()+"线程..........执行了"+i);
        }
    }
}

问题:为啥在重写的run方法中有异常只能try,不能throws?

原因:继承的Thread中的run方法没有抛异常,所以在子类中重写完run方法之后就不能抛,只能try

线程优先级

public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了......"+i);
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("金莲");

        MyThread1 t2 = new MyThread1();
        t2.setName("阿庆");

        /*
           获取两个线程的优先级
           MIN_PRIORITY = 1 最小优先级 1
           NORM_PRIORITY = 5 默认优先级 5
           MAX_PRIORITY = 10 最大优先级 10
         */
        //System.out.println(t1.getPriority());
        //System.out.println(t2.getPriority());

        //设置优先级
        t1.setPriority(1);
        t2.setPriority(10);

        t1.start();
        t2.start();
    }
}

守护线程

public class Test01 {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("金莲");

        MyThread2 t2 = new MyThread2();
        t2.setName("阿庆");

        //将t2设置成守护线程
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }
}


public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了......"+i);
        }
    }
}

public class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了..."+i);
        }
    }
}

比如QQ聊天，聊天的同时可以传输文件，可以把传输文件的过程设置为守护线程

礼让线程

只是尽可能的礼让

public class Test01 {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("金莲");

        MyThread1 t2 = new MyThread1();
        t2.setName("阿庆");


        t1.start();
        t2.start();
    }
}

public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了......"+i);
            Thread.yield();
        }
    }
}

插入线程

就是插队

public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了......"+i);
        }
    }
}

public class Test01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread1 t1 = new MyThread1();
        t1.setName("金莲");
        t1.start();

        /*
          表示把t1插入到当前线程之前,t1要插到main线程之前,所以当前线程就是main线程
         */
        t1.join();

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

方法二：实现接口

基本过程：

  1. 创建类,实现Runnable接口
  2. 重写run方法,设置线程任务
  3. 利用Thread类的构造方法:Thread(Runnable target),创建Thread对象(线程对象),将自定义的接口实现类当参数传递到Thread构造函数中 -> 这一步是让我们自己定义的类成为一个真正的线程类对象
  4. 调用Thread中的start方法,开启线程,jvm自动调用run方法
public class Test01 {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        /*
           Thread(Runnable target)
         */
        Thread t1 = new Thread(myRunnable);
        //调用Thread中的start方法,开启线程
        t1.start();

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

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"...执行了"+i);
        }
    }
}

还可以使用匿名内部类创建多线程：

1.new 接口/抽象类(){
      重写方法
  }.重写的方法();

2.接口名/类名 对象名 = new 接口/抽象类(){
      重写方法
  }
 对象名.重写的方法();

public class Test02 {
    public static void main(String[] args) {
        /*
          Thread(Runnable r)
          Thread(Runnable target, String name) :name指的是给线程设置名字
         */

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"...执行了"+i);
                }
            }
        },"阿庆").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"...执行了"+i);
                }
            }
        },"金莲").start();
    }
}

两种创建方式的区别：

  1. 继承Thread:继承只支持单继承,有继承的局限性
  2. 实现Runnable:没有继承的局限性, MyThread extends Fu implements Runnable

方法三：Callable接口

  1. 概述:Callable<V>是一个接口,类似于Runnable

  2. 方法:

    V call() -> 设置线程任务的,类似于run方法

  3. call方法和run方法的区别:

    • 相同点:都是设置线程任务的
    • 不同点:
      • call方法有返回值,而且有异常可以throws
      • run方法没有返回值,而且有异常不可以throws

  4. 获取call方法返回值: FutureTask<V>

    • FutureTask<V> 实现了一个接口: Future <V>
    • FutureTask<V>中有一个方法: V get()-> 获取call方法的返回值
public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        return "...的故事";
    }
}

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        /*
           FutureTask(Callable<V> callable)
         */
        FutureTask<String> futureTask = new FutureTask<>(myCallable);

        //创建Thread对象-> Thread(Runnable target)
        Thread t1 = new Thread(futureTask);
        t1.start();

        //调用get方法获取call方法返回值
        System.out.println(futureTask.get());
    }
}

方法四：线程池

之前来一个线程任务,就需要创建一个线程对象去执行,用完还要销毁线程对象。

如果线程任务多了,就需要频繁创建线程对象和销毁线程对象,这样会耗费内存资源,所以我们就想线程对象能不能循环利用,用的时候直接拿线程对象,用完还回去。

  1. 如何创建线程池对象: 工具类-> Executors

  2. 获取线程池对象:Executors中的静态方法: static ExecutorService newFixedThreadPool(int nThreads)

    • 参数:指定线程池中最多创建的线程对象条数
    • 返回值ExecutorService 是线程池,用来管理线程对象

  3. 执行线程任务: ExecutorService中的方法

    • Future<?> submit(Runnable task) 提交一个Runnable任务用于执行
    • Future<T> submit(Callable<T> task)提交一个Callable任务用于执行

  4. submit方法的返回值: Future接口 -> 用于接收run方法或者call方法返回值的,但是run方法没有返回值,所以可以不用Future接收,执行call方法需要用Future接收。

    Future中有一个方法:V get() 用于获取call方法返回值

  5. ExecutorService中的方法: void shutdown() 启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"...执行了");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService es = Executors.newFixedThreadPool(2);
        es.submit(new MyRunnable());
        es.submit(new MyRunnable());
        es.submit(new MyRunnable());

        //es.shutdown();//关闭线程池对象
    }
}

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 1;
    }
}

public class Test02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(2);
        Future<Integer> future = es.submit(new MyCallable());
        System.out.println(future.get());
    }
}
秀秀_heo
关注
专栏目录
java创建线程的四种方式
weixin_45861045的博客
06-13 2270
java创建线程的四种方式
java 创建线程的几种方式
08-31
在Java编程语言中，创建线程是实现多任务并发处理的关键。本文将详细阐述两种主要的线程创建方式，以及它们的特点和使用场景。 首先，第一种创建线程的方式是通过继承`java.lang.Thread`类。当你创建一个新的类并...
Java创建线程的方式
weixin_58724261的博客
06-09 1663
Java创建线程的四种方式包括： 继承Thread类并重写run()方法 实现Runnable接口并重写run()方法 实现Callable接口并重写call()方法 使用线程池创建线程
Java多线程 - Java创建线程的4种方式
你今天真好看呀
02-18 9772
文章目录1. Java创建线程有哪几种方式？1.1 线程创建方法一：继承Thread类创建线程类1.2 线程创建方法二：实现Runnable接口创建线程目标类1.3 优雅创建Runnable线程目标类的两种方式1.4 通过实现Runnable接口的方式创建线程目标类的优缺点1.5 线程创建方法三：使用Callable和FutureTask创建线程1.6 线程创建方法四：通过线程池创建线程2. 线程的 run() 和 start() 有什么区别？3. Runnable 和 Thread 用哪个好？4. Fut
java创建线程的方式到底有几种？(详解)
zhenghuishengq的博客
11-21 9154
java实现多线程的两种方式
java创建线程的三种方式
热门推荐
qq_50867577的博客
06-05 1万+
线程创建的三种方式及其对比
java创建线程的5种方法
咚咚呛的博客
07-16 7219
java创建线程的5种方法
java 创建线程的三种方式、创建线程池的四种方式
我这孩子从小记性就不好，什么东西都要写下来才放心
03-30 6636
概要： java创建线程的三种方式： ** 继承Thread类创建线程类** ** 实现Runnable接口** ** 通过Callable和Future创建线程** java创建线程池的四种方式： newCachedThreadPool_ **创建一个可缓存的线程池，如果线程池长度超过处理需求，可灵活回收空闲线程，若无可回收，则新建线程 **newFixedThreadPool_ **创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待** newScheduledT.
Java创建线程的三种方式
gyxx1998的博客
07-10 1715
在Java中可通过三种方式来实现多线程：继承Thread类，重写方法实现Runnable接口，重写方法实现Callable接口，重写方法并使用获取call()方法的返回结果利用Thread类实现多线程主要步骤：利用Runnable接口实现多线程主要步骤：利用Callable接口实现多线程主要步骤：下面为三种方式的实现...
JAVA创建线程的几种方式
weixin_49698553的博客
07-06 1262
通过继承Thread类来创建并启动线程的步骤如下：定义Thread类的子类，并重写该类的run()方法，该run()方法将作为线程执行体。创建Thread子类的实例，即创建了线程对象。调用线程对象的start()方法来启动该线程。通过实现Runnable接口来创建并启动线程的步骤如下：定义Runnable接口的实现类，并实现该接口的run()方法，该run()方法将作为线程执行体。创建Runnable实现类的实例，并将其作为Thread的target来创建Thread对象，Thread对象为线程对象。调用线
java创建线程的方式有几种？
禾日香的博客
03-06 1305
java创建线程的方式有几种？这四种究其底层都是实现Runnable接口实现的。
Java创建线程三种方式的优缺点
08-26
Java创建线程三种方式的优缺点 Java创建线程主要有三种方式：继承Thread类创建线程、实现Runnable接口创建线程和实现Callable和Future创建线程。每种方式都有其优缺点，在实际开发中，选择合适的方式非常重要。 ...
Java 创建线程的两个方法详解及实例
08-31
Java 创建线程的两个方法详解及实例 Java 语言中提供了两种方式来创建线程，即通过扩展 Thread 类和实现 Runnable 接口。这两种方法都可以创建多线程程序，但是它们在实现方式和应用场景上有所不同。 扩展 Thread ...
java创建线程的两种方法区别
08-30
Java 创建线程的两种方法区别 Java 中创建线程有两种方法：继承 Thread 类和实现 Runnable 接口。这两种方法的实现机制不同，导致了不同的线程行为。本文将通过实例代码对这两种方法进行比较和分析，帮助读者更好地...
springboot基于大数据技术的电影推荐系统的设计与实现
qq_1744828575的博客
11-21 738
该系统综合运用了数据挖掘、机器学习和用户行为分析等先进技术，不仅能够实时监控用户的观影习惯和偏好，还能学习用户的历史互动，如评分、评论及搜索历史，以动态调整推荐算法。管理员通过强大的后台管理功能，维护电影信息库，优化用户体验，并保障系统的高效运行。这样的系统不仅极大地丰富了用户的娱乐体验，也为电影产业的市场营销提供了数据支持，开辟了新的商业价值途径。按照软件工程的流程来说，在系统的详细设计与实现阶段，要把模块、视图、模板进行相应的组合完成一个个所需的功能，此章将会把设计中模块一一说明如何设计和实现的。
企业办公自动化：Spring Boot OA管理系统详解
2401_85702623的博客
11-23 305
同时，一个大型的计算机网站系统，必须有一个正确的设计指导思想，通过合理选择数据结构、网络结构、操作系统以及开发环境，构成一个完善的网络体系结构，才能充分发挥计算机信息管理的优势。可以保证关键数据的安全性。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
JVM参数总结
Mr.W的博客
11-20 992
在本篇文章中，你将掌握最常用的 JVM 参数配置。
如何将Spring Cloud Task发布Data Flow上执行？
最新发布
HBLOG
11-23 602
Spring Cloud Task 是 Spring Cloud 生态系统中的一个项目，专门用于简化短生命周期微服务的开发。它提供了一种创建、运行和监控一次性任务的方式，这些任务通常是非持久性的，并在完成后终止。简化任务开发：通过提供一组简单的注解和配置，开发者可以快速创建短生命周期的任务。任务执行和管理：支持任务的启动、停止和重启，并可以与 Spring Batch 集成以处理复杂的批处理任务。任务监控：提供任务执行的详细信息和状态报告，帮助开发者监控任务的执行情况。与Spring生态系统集成。
Java多线程简介
qq_45721579的博客
11-20 976
线程作为能够将服务器资源利用率发挥到极致的关键元素，对于现代 Java 开发而言，深入了解和掌握线程是不可或缺的技能之一。在本章节中，我们重点介绍了线程的基本使用方式、常用参数以及常用方法，并透过案例讨论了多线程可能导致的并发安全问题以及产生这些问题的原因。这一深入探讨为后续学习奠定了基础。虽然线程的使用可以提升服务器资源利用率，但若使用不当、控制不得当，就可能导致系统出现严重问题。在下一节中，我们将详细探讨如何合理、高效、安全地使用线程，以确保系统的稳定性和性能表现。
java 创建线程
06-01
Java 中创建线程有以下两种方式： 1. 继承 Thread 类，并重写 run() 方法： ```java public class MyThread extends Thread { @Override public void run() { // 线程执行的代码 } } // 创建线程并启动 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

秀秀_heo

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

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

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

打赏作者

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

抵扣说明：

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

余额充值