创建线程的4种方式

最新推荐文章于 2024-05-22 10:36:08 发布
最新推荐文章于 2024-05-22 10:36:08 发布
阅读量198 收藏 1
点赞数 1
分类专栏： JUC 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pinenutssg1/article/details/109764856
版权

Java并发

一、创建线程的4种方式

概述：1）继承Thread类

​ 2）实现Runnable接口

​ 3）实现Callable接口 后面两种，jdk5后

​ 4）使用线程池

匿名内部类：https://www.cnblogs.com/wuhenzhidu/p/anonymous.html

4大方法：https://www.cnblogs.com/li666/p/11139968.html

继承Thread类

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
  3. 创建Thread类的子类的对象
  4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()
/**
 *                  创建线程的4种方式：1、继承Thread
 *                                   2、实现Runnable
 *                                   3、实现Callable，搭配FutureTask
 *                                   4、构建线程池
 *
 *
 *
 *
 *                  方式一：继承Thread类
 *
 *                  两个注意点：
 *                      1、我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。
 *                      2、如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()。
 *
 *
 *
 * @author sgstar
 * @create 2020-11-17 15:31
 */

// 这个例子是启用一个新的类，去继承Thread，
public class MyThread {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");

        ThreadDemo1 threadDemo1 = new ThreadDemo1();
        threadDemo1.setName("demo1");
        threadDemo1.start();
    }
}


class ThreadDemo1 extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
    }
}

    // 这个例子，是直接使用主类继承Thread，创建多线程。并且从输出结果来看，并不是线程调用了start()方法，它就先执行。
    // 然后我们可以使用sleep，说句晚安，再看看结果。
    /*
public class MyThread extends Thread {
    public static void main(String[] args) {

        // 创建一个新线程
        MyThread threadDemo1 = new MyThread();
        // 设置线程的名称
        threadDemo1.setName("demo1");
        // 开启线程
        threadDemo1.start();

//        try {
//            sleep(1);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        
        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
    }
} */

    // 3、匿名内部类：1、匿名子类（继承父类） 2、实现接口的匿名类
//public class MyThread {
//    public static void main(String[] args) {
//
//        new Thread() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//            }
//        }.start();
//
//
//        //new到.start()；这直接，整部分的内容表示Thread类的子类对象，
//        // 然后.start就会调用run()方法，start就把线程给开启，然后调用run()方法
//
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//    }
//
//}

两个注意点： 1、我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。
2、如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()。

实现Runnable接口

  1. 创建一个实现了Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法：run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  5. 通过Thread类的对象调用start()

匿名内部类：https://www.cnblogs.com/wuhenzhidu/p/anonymous.html

1、匿名子类（继承父类） 2、实现接口的匿名类

/**
 *                                             方式二：实现Runnable接口
 * @author sgstar
 * @create 2020-11-17 16:41
 */

// 1、这个例子是启用一个新的类，去实现Runnable，
public class MyRunnable {
    public static void main(String[] args) {

        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");

        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        Thread t1 = new Thread(threadDemo2);
        t1.setName("demo2");
        t1.start();

    }
}

class ThreadDemo2 implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
    }
}

// 2、这个例子，是直接使用主类实现Runnable，创建多线程。
//public class MyRunnable implements Runnable{
//    public static void main(String[] args) {
//
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//
//        MyRunnable threadDemo2 = new MyRunnable();
//        Thread t1 = new Thread(threadDemo2);
//        t1.setName("demo2");
//        t1.start();
//
//    }
//
//    @Override
//    public void run() {
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//    }
//}

    // 3、匿名内部类
//           lambda express
//                       2.1 口诀
//                       拷贝小括号，写死右箭头，落地大括号

//public class MyRunnable {
//    public static void main(String[] args) {
//
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//            }
//        },"SunG").start();
//
//        new Thread(() -> {
//                System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//            },"new").start();
//    }
//}

实现Callable接口

  1. 创建一个类并实现Callable接口
  2. 重写call()方法，将所要完成的任务的代码写进call()方法中，需要注意的是call()方法有返回值，并且可以抛出异常
  3. 如果想要获取运行该线程后的返回值，需要创建Future接口的实现类的对象，即FutureTask类的对象，调用该对象的get()方法可获取call()方法的返回值
  4. 使用Thread类的有参构造器创建对象，将FutureTask类的对象当做参数传进去，然后调用start()方法开启并运行该线程。
/**
 *
 *           这像认识一个不认识的同学，我可以找中间人介绍。中间人是什么？java多态，一个类可以实现多个接口！！
 *           FutureTask<Integer> ft = new FutureTask<Integer>(new MyThread());
 *           new Thread(ft, "AA").start();
 *           运行成功后如何获得返回值？ft.get();
 *
 *          FutureTask的get方法需要放在，最后使用，因为如果放在中间的话，主线程会等待，返回值返回了之后才执行
 *
 *
 *        面试题：Callable接口与Runnable接口的区别？
 *
 *    答：   （1）是否有返回值
 *          （2）是否抛异常
 *          （3）落地方法不一样，一个是run，一个是call
 *
 *
 * @author sgstar
 * @create 2020-11-17 18:40
 */
//  1、这个例子是启用一个新的类，去实现Callable，
public class MyCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");

        ThreadDemo3 threadDemo3 = new ThreadDemo3();
        FutureTask<Integer> futureTask = new FutureTask(threadDemo3);
        Thread t1 = new Thread(futureTask);
        t1.setName("demo3");
        t1.start();
        System.out.println(futureTask.get());

    }
}

class ThreadDemo3 implements Callable {

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
        return 1988;
    }
}

//  2、这个例子，是直接使用主类实现Callable，创建多线程。，
//public class MyCallable implements Callable{
//    public static void main(String[] args) throws ExecutionException, InterruptedException {
//
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//
//        MyCallable threadDemo3 = new MyCallable();
//        FutureTask<Integer> futureTask = new FutureTask(threadDemo3);
//        Thread t1 = new Thread(futureTask);
//        t1.setName("demo3");
//        t1.start();
//        System.out.println(futureTask.get());
//
//    }
//
//    @Override
//    public Object call() throws Exception {
//            System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//            return 1988;
//    }
//}

// 3、匿名内部类，不好用。取不到，返回值。

使用线程池

  1. 使用Executors类中的newFixedThreadPool(int num)方法创建一个线程数量为num的线程池

  2. 调用线程池中的execute()方法执行由实现Runnable接口创建的线程；调用submit()方法执行由实现Callable接口创建的线程

  3. 调用线程池中的shutdown()方法关闭线程池

    MyThreadPool我自己的，多家实例总和

/**
 *                      方式四：使用线程池
 *
 *                     使用线程池技术，
 *							ExecutorService，
 *							Executors工具类创建线程池，三种方式，这里列举一种
 *							execute()方法用于实现Runnable接口创建的线程
 *							submit()方法适用于实现Callable接口创建的线程
 *                    
 *                       
 *
 *
 * @author sgstar
 * @create 2020-11-17 19:12
 */
//  1、这个例子是启用新的类，去使用ThreadPool，
public class MyThreadPool {

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

        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
        // 通过线程池工厂创建线程数量为5的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        // 执行线程,execute()适用于实现Runnable接口创建的线程
        executorService.execute(new ThreadRunnableDemo5());
        // 执行线程，submit()适用于实现Callable接口创建的线程
        ThreadCallableDemo6 threadCallableDemo6 = new ThreadCallableDemo6();
        Future<Integer> future = executorService.submit(threadCallableDemo6);
        // 获取call()方法的返回值
        System.out.println(future.get());
        // 关闭线程池
        executorService.shutdown();
    }
}

class ThreadRunnableDemo5 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果Runnable");
    }
}

class ThreadCallableDemo6 implements Callable {
    @Override
    public Integer call() {
        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果Callable");
        return 1988;
    }
}


// 这个方法不行，在使用submit出现了错误，舍弃
//public class MyThreadPool implements Runnable,Callable{
//
//    public static void main(String[] args) throws ExecutionException, InterruptedException {
//
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//        // 通过线程池工厂创建线程数量为5的线程池
//        ExecutorService executorService = Executors.newFixedThreadPool(5);
//        // 执行线程,execute()适用于实现Runnable接口创建的线程
//        executorService.execute(new MyThreadPool());
//        // submit()适用于实现Callable接口创建的线程
//        MyThreadPool myThreadPool = new MyThreadPool();
//        Future<Integer> future = executorService.submit(myThreadPool);
//        // 获取call()方法的返回值
//        System.out.println(future.get());
//        // 关闭线程池
//        executorService.shutdown();
//    }
//
//    @Override
//    public void run() {
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果Runnable");
//    }
//
//    @Override
//    public Integer call() throws Exception {
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果Callable");
//        return 1988;
//    }
//}




//3、这个例子是使用匿名内部类，但是不能获取返回值
//public class MyThreadPool {
//
//    public static void main(String[] args) {
//
//        System.out.println(Thread.currentThread().getName() + ":" + "输出的结果");
//        ExecutorService executorService = Executors.newFixedThreadPool(2);
//        executorService.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName() + ":" + "输出的结果Runnable");
//            }
//        });
//
//        executorService.submit(new Callable() {
//            @Override
//            public Integer call() {
//                System.out.println(Thread.currentThread().getName() + ":" + "输出的结果Callable");
//                return 1988;
//            }
//        });
//        executorService.shutdown();
//    }
//}

​ 周阳老师的，线程池该用哪个？更加全面，汇总，介绍线程池的总的方法。这里简单介绍线程池方法

/**
 *          1.继承Thread
 *          2.实现Runnable
 *          3.实现Callable，搭配FutureTask
 *          4.使用线程池技术，ExecutorService，Executors工具类，execute()方法，submit()方法
 *                  java提供了，3种不同的创建线程池的方法，但是三种不同的方法实际上可以汇总成一个方法
 *                      ThreadPoolExecutor()，这里面一共有7大参数
 *
 *
 * @author sgstar
 * @create 2020-11-17 21:38
 */
public class MyThreadPoolDemo {
    public static void main(String[] args) {

//        ExecutorService threadPool = Executors.newFixedThreadPool(5);// 一个池子5个工作线程
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();// 一个池子1个工作线程
//        ExecutorService threadPool = Executors.newCachedThreadPool();//一个池子N个工作线程
//        try {
//            for (int i = 1; i <= 10; i++) {
//                threadPool.execute(() -> {
//                    System.out.println(Thread.currentThread().getName() + "\t办理业务");
//                });
//                // 睡1秒钟，延时
//                try { TimeUnit.SECONDS.sleep(1); } catch (Exception e) { e.printStackTrace(); }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            threadPool.shutdown();
//        }


        System.out.println(Runtime.getRuntime().availableProcessors()); // 内核数

        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5, // 内核数+1  +2
                2L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());

        try {
            for (int i = 0; i < 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t办理业务");
                    // try { TimeUnit.SECONDS.sleep(1); } catch (Exception e) { e.printStackTrace(); }
                });
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }

--------------------------------------四种创建线程方法对比--------------------------------------

实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值，因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：

1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。

2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。

3、但是编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。

4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）。

5、前三种的线程如果创建关闭频繁会消耗系统资源影响性能，而使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池

注：在前三种中一般推荐采用实现接口的方式来创建多线程

Thread和Runnable的实质是继承关系，没有可比性。无论使用Runnable还是Thread，都会new Thread，然后执行run方法。用法上，如果有复杂的线程操作需求，那就选择继承Thread，如果只是简单的执行一个任务，那就实现runnable。

其实，前面三种方法，到最后都需要NEW THREAD()，有人说创建线程这3个都算一种方法。也可以，但是，我觉得面试的时候，面试官应该更加倾向于4种这样的回答。

那么工作中用哪个创建线程池的方法呢？一个都不用，用自定义的。

在这里插入图片描述

参考：https://blog.csdn.net/longshengguoji/article/details/41126119

​ https://www.cnblogs.com/li666/p/11139968.html

​

松果pine吃玉米
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java创建线程的几种方式
QJjping的博客
05-14 6367
方式一：继承Thread类 新建一个类并该类声明为Thread的子类。 这个子类应该重写run类的方法。例如，计算大于规定值的素数的线程可以写成如下： class PrimeThread extends Thread { long minPrime; PrimeThread(long minPrime) { this.minPrime = minPrime; } public void run() {
创建线程池的四种方式
A_com_Z的博客
08-02 1590
创建线程池的方式有四种方式，分别是newCatchThreadPool、newFixedThreadPool、newScheduleThreadPool、newSingleThreadExecutor。以下四种方式的案例实现 1.newCatchTreadPool 特点：可以创建一个可以缓存的线程池 public static void newCachedThreadPool() { // 创建一个课缓存的线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，没回收的话就新建线程 Ex.
创建线程池的七种方式
jiaomubai的博客
06-02 1万+
创建线程池的7种方式
线程池的几种创建方式
最新发布
szchen2的博客
05-22 395
/ 自定义策略。
线程池7种创建方式
weixin_52012588的博客
05-23 1271
一 线程的缺点 1：现成的创建需要开辟内存资源：本地方法栈，虚拟机 2： 3： 二 线程池 1.定义：使用池化技术来管理和使用线程的技术 2.线程池的创建方式（共7种）： （1）创建固定个数的线程池 ExecutorService service = Executors.newFixedThreadPool(4); 问题：创建了十个线程来执行2个任务，那当前程序创建了几个线程？ （2）创建带缓存的线程池 public class ThreadPoolDemo3 { public static vo
线程的四种创建方式
weixin_48950939的博客
04-14 3598
一、继承Thread类 创建类继承Thread类，并重写run()方法，通过start()启动线程。以继承的方式创建的线程可以使用当前类来获取线程的名称、状态、优先级等相关信息，因为其继承了Thread类的相关方法。 public class MyThread extends Thread{ @Override public void run(){ //...... //...... //业务代码 } } public cl
java 创建线程的几种方式
08-31
首先，第一种创建线程的方式是通过继承`java.lang.Thread`类。当你创建一个新的类并扩展Thread类时，你需要重写它的`run()`方法。例如： ```java public class MyThread extends Thread { public void run() { ...
Java创建线程的两种方式
09-01
Java提供了两种主要的方式来创建线程，分别是继承`Thread`类和实现`Runnable`接口。这两种方式各有优缺点，适用于不同的场景。 ### 继承Thread类 当你选择继承`Thread`类来创建线程，你需要按照以下步骤操作： 1....
Java创建线程三种方式的优缺点
08-26
Java创建线程主要有三种方式：继承Thread类创建线程、实现Runnable接口创建线程和实现Callable和Future创建线程。每种方式都有其优缺点，在实际开发中，选择合适的方式非常重要。 继承Thread类创建线程 -----------...
python线程的几种创建方式详解
09-18
主要介绍了python线程的几种创建方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程-对比创建多线程的两种方式
01-25
Java多线程编程中，创建线程主要有两种方式：继承`Thread`类和实现`Runnable`接口。这两种方式虽然都能实现多线程，但它们在实际应用中有着不同的特性和适用场景。 首先，我们来看看继承`Thread`类的方式。这种方式...
Java线程的四种创建方式
Songbl_的博客
08-31 185
线程创建
线程创建的四种方式
weixin_44989630的博客
05-16 1万+
java中创建线程的四种方法以及区别 Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 4）使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的方法。 ------------------------继承Thread类创建线程--------------------- .
线程的4种创建方法
m0_64838208的博客
05-04 301
多线程之线程的4种创建方法
Java基础题
fanyun7654的专栏
07-16 1831
第一，谈谈final, finally, finalize的区别。 　　最常被问到。　　 　　第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?　　 　　第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统
面试官问我：创建线程有几种方式？我笑了
烟雨星空的博客
10-24 1616
前言 多线程在面试中基本上已经是必问项了，面试官通常会从简单的问题开始发问，然后再一步一步的挖掘你的知识面。 比如，从线程是什么开始，线程和进程的区别，创建线程有几种方式，线程有几种状态，等等。 接下来自然就会引出线程池，Lock，Synchronized，JUC的各种并发包。然后就会引出 AQS、CAS、JMM、JVM等偏底层原理，一环扣一环。 这一节我们不聊其他的，只说创建线程有几种方式。 是不是感觉非常简单，不就是那个啥啥那几种么。 其实不然，只有我们给面试官解释清楚了，并加上我们自己的理解，才能在面
JAVA核心技术笔记总结--第14章 线程总结
weixin_30381793的博客
08-29 277
转载自https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20%E5%B9%B6%E5%8F%91.md 0、进程和线程的区别： 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，上下文切换大约需要上千条指令，一个进程包含1--n个线程。（进程是资源分配的最小单位） 线程：同一类线程共享代码和数据空间...
Java创建线程的四种方式
蔡茂的博客
01-21 1107
JavaSE学习——创建线程的三种方式 通过继承Thread类创建 通过实现Runnable接口创建 通过Callable和Future创建 1.通过继承Thread类创建 (1) 定义Thread类的子类并覆写该类的run()方法 //音乐线程 class Music extends Thread{ @Override public void run(){ for(int i = 0; ...
java 创建线程的三种方式、创建线程池的四种方式
热门推荐
SmileTimLi的博客
02-23 4万+
概要： java创建线程的三种方式： 继承Thread类创建线程类 实现Runnable接口 通过Callable和Future创建线程 java创建线程池的四种方式： newCachedThreadPool 创建一个可缓存的线程池，如果线程池长度超过处理需求，可灵活回收空闲线程，若无可回收，则新建线程 newFixedThread...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值