精华内容
下载资源
问答
  • 创建类有几种方式
    万次阅读
    2022-07-07 13:00:07

    Java中创建对象共有几种方式?

    5种创建对象的方法:

    • 使用 new 关键字调用对象的构造器;
    • 使用 Object 类的 clone() 方法;
    • 使用 Class 类的 newInstance() 方法;
    • 使用 Constructor 类的 newInstance() 方法;
    • 使用对象流 ObjectInputStream的readObject()方法读取序列化对象;

    1.通过new申请对象空间(堆空间)

    Handsome handsome = new Handsome();
    

    2.通过Class类中的newInstance()方法

    Handsome handsome = Handsome.class.newInstance();
    

    3.通过Constructor类中的newInstance()方法

    Handsome handsome = Handsome .class.getConstructor().newInstance();
    

    4.通过Object类中的clone()方法

    类对象实现Cloneable接口
    不会执行构造方法
    设计模式—>Prototype原型模式

    Handsome handsome1 = new Handsome ("");
    Handsome handsome2 = (Handsome ) handsome1.clone();
    

    5.通过对象的反序列化

    Handsome handsome1 = new Handsome("反序列化一个对象");
     
    // 序列化一个girlFriend
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("Handsome.obj"));
    objectOutputStream.writeObject(handsome1);
    objectOutputStream.close();
     
    // 反序列化出来
    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("Handsome.obj"));
    Handsome handsome2 = (Handsome) objectInputStream.readObject();
    objectInputStream.close();
    

    我的学习论坛

    HandsomeForum:用Java编写的学习论坛,打造我们自己的圈子!(http://huangjunjie.vip:66)
    文章链接:http://huangjunjie.vip:66/blog/read/rwg7mk59r1fj1h80si

    更多相关内容
  • 创建线程的几种方式

    万次阅读 2021-08-23 09:39:14
    Java中创建线程主要种方式: 一、继承Thread类创建线程 (1)定义Thread的子类,并重写该的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 (2)创建Thread子类的实例...

    Java中创建线程主要有三种方式:

    一、继承Thread类创建线程类

    (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

    (2)创建Thread子类的实例,即创建了线程对象。

    (3)调用线程对象的start()方法来启动该线程。

    
    public class FirstThreadTest extends Thread {
    
        int i = 0;
    
        //重写run方法,run方法的方法体就是现场执行体
        public void run() {
            for (; i < 100; i++) {
                System.out.println(getName() + "  " + i);
            }
        }
    
        public static void main(String[] args) {
    
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "  : " + i);
                if (i == 50) {
                    new FirstThreadTest().start();
                    new FirstThreadTest().start();
                }
            }
        }
    }
    

    上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。

    二、通过Runnable接口创建线程类

    (1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。

    (2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。

    (3)调用线程对象的start()方法来启动该线程。

    public class RunnableThreadTest implements Runnable{
            private int i;
            public void run()
            {
                for(i = 0;i <100;i++)
                {
                    System.out.println(Thread.currentThread().getName()+" "+i);
                }
            }
            public static void main(String[] args)
            {
                for(int i = 0;i < 100;i++)
                {
                    System.out.println(Thread.currentThread().getName()+" "+i);
                    if(i==20)
                    {
                        RunnableThreadTest rtt = new RunnableThreadTest();
                        new Thread(rtt,"新线程1").start();
                        new Thread(rtt,"新线程2").start();
                    }
                }
    
            }
    }
    

    三、通过Callable和Future创建线程

    (1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。

    (2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。注释:FutureTask是一个包装器,它通过接受Callable来创建,它同时实现了Future和Runnable接口。

    (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。

    (4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

    package com.nf147.Constroller;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class CallableThreadTest implements Callable<Integer> {
    
    
        public static void main(String[] args) {
            CallableThreadTest ctt = new CallableThreadTest();
            FutureTask<Integer> ft = new FutureTask<>(ctt);
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
                if (i == 20) {
                    new Thread(ft, "有返回值的线程").start();
                }
            }
            try {
                System.out.println("子线程的返回值:" + ft.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
        }
    
        @Override
        public Integer call() throws Exception {
            int i = 0;
            for (; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
            return i;
        }
    }
    

    四、创建线程的三种方式的对比

    1.采用实现Runnable、Callable接口的方式创见多线程时,优势是:

    (1)线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。

    (2)在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。

    劣势是:

    (1)编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。

    2.使用继承Thread类的方式创建多线程时优势是:

    (1)编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。

    劣势是:

    (1)线程类已经继承了Thread类,所以不能再继承其他父类。

    展开全文
  • 创建线程池几种方式

    万次阅读 2020-05-04 22:15:27
    创建线程池几种方式一、Executors二、ThreadPoolExecutor 一、Executors Executors是一个线程相关的工具。主要提供了以下几种创建线程池的方法: index method corePoolSize maximumPoolSize ...

    一、Executors

    Executors是一个线程相关的工具类。主要提供了以下几种创建线程池的方法:

    indexmethodcorePoolSizemaximumPoolSizekeepAliveTimeunitworkQueue
    1newCachedThreadPool0Integer.MAX_VALUE60LTimeUnit.SECONDSSynchronousQueue
    2newFixedThreadPool自定义与corePoolSize相同0LTimeUnit.MILLISECONDSLinkedBlockingQueue
    3newSingleThreadExecutor110LTimeUnit.MILLISECONDSLinkedBlockingQueue
    4newScheduledThreadPool自定义Integer.MAX_VALUE0NANOSECONDSDelayedWorkQueue
    5newSingleThreadScheduledExecutor1Integer.MAX_VALUE0NANOSECONDSDelayedWorkQueue

    第1,4,5种:线程最大数量是Integer.MAX_VALUE,当执行大量耗时任务时,容易造成堆外内存溢出
    第2,3种:使用的的阻塞队列为无边界队列,当任务量过大时,可能会导致内存溢出

    注意: 在java8中新添加了newWorkStealingPool

    二、ThreadPoolExecutor

    ThreadPoolExecutor(int corePoolSize, //核心线程数量
                       int maximumPoolSize, // 最大线程数量
                       long keepAliveTime, // 存活时间 
                       TimeUnit unit, // 时间单位
                       BlockingQueue<Runnable> workQueue, //阻塞队列
                       ThreadFactory threadFactory) // 拒绝策略
    

    注意: 有多于corePoolSize但小于maximumPoolSize线程正在运行,则仅当队列已满时才会创建新线程

    在这里插入图片描述

    展开全文
  • 在 Java 语言中,并发编程都是通过创建线程池来实现的,而线程池的创建方式很多,每线程池的创建方式都对应了不同的使用场景,总体来说线程池的创建可以分为以下两: 通过 ThreadPoolExecutor 手动创建...

    在 Java 语言中,并发编程都是通过创建线程池来实现的,而线程池的创建方式也有很多种,每种线程池的创建方式都对应了不同的使用场景,总体来说线程池的创建可以分为以下两类:

    • 通过 ThreadPoolExecutor 手动创建线程池。
    • 通过 Executors 执行器自动创建线程池。

     

    而以上两类创建线程池的方式,又有 7 种具体实现方法,这 7 种实现方法分别是:

    • Executors.newFixedThreadPool:创建一个固定大小的线程池,可控制并发的线程数,超出的线程会在队列中等待。
    • Executors.newCachedThreadPool:创建一个可缓存的线程池,若线程数超过处理所需,缓存一段时间后会回收,若线程数不够,则新建线程。
    • Executors.newSingleThreadExecutor:创建单个线程数的线程池,它可以保证先进先出的执行顺序。
    • Executors.newScheduledThreadPool:创建一个可以执行延迟任务的线程池。
    • Executors.newSingleThreadScheduledExecutor:创建一个单线程的可以执行延迟任务的线程池。
    • Executors.newWorkStealingPool:创建一个抢占式执行的线程池(任务执行顺序不确定)【JDK 1.8 添加】。
    • ThreadPoolExecutor:手动创建线程池的方式,它创建时最多可以设置 7 个参数。

    接下来我们分别来看这 7 种线程池的具体使用。

    1.FixedThreadPool

    创建一个固定大小的线程池,可控制并发线程数。使用 FixedThreadPool 创建 2 个固定大小的线程池,具体实现代码如下:

    public static void fixedThreadPool() {
        // 创建 2 个线程的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
    
        // 创建任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
            }
        };
    
        // 线程池执行任务(一次添加 4 个任务)
        // 执行任务的方法有两种:submit 和 execute
        threadPool.submit(runnable);  // 执行方式 1:submit
        threadPool.execute(runnable); // 执行方式 2:execute
        threadPool.execute(runnable);
        threadPool.execute(runnable);
    }

    以上程序的执行结果如下图所示:

    如果觉得以上方法比较繁琐,还用使用以下简单的方式来实现线程池的创建和使用:

    public static void fixedThreadPool() {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        // 执行任务
        threadPool.execute(() -> {
            System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
        });
    }

    2.CachedThreadPool

    创建一个可缓存的线程池,若线程数超过任务所需,那么多余的线程会被缓存一段时间后才被回收,若线程数不够,则会新建线程。CachedThreadPool 使用示例如下:

    public static void cachedThreadPool() {
        // 创建线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();
        // 执行任务
        for (int i = 0; i < 10; i++) {
            threadPool.execute(() -> {
                System.out.println("任务被执行,线程:" + Thread.currentThread().getName());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
            });
        }
    }

    以上程序的执行结果如下图所示:

    从上述结果可以看出,线程池创建了 10 个线程来执行相应的任务。

    使用场景

    CachedThreadPool 是根据短时间的任务量来决定创建的线程数量的,所以它适合短时间内有突发大量任务的处理场景。

    3.SingleThreadExecutor

    创建单个线程的线程池,它可以保证先进先出的执行顺序。SingleThreadExecutor 使用示例如下:

    public static void singleThreadExecutor() {
        // 创建线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 执行任务
        for (int i = 0; i < 10; i++) {
            final int index = i;
            threadPool.execute(() -> {
                System.out.println(index + ":任务被执行");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
            });
        }
    }

    以上程序的执行结果如下图所示:

    单个线程的线程池有什么意义?

    单个线程的线程池相比于线程来说,它的优点有以下 2 个:

    • 可以复用线程:即使是单个线程池,也可以复用线程。
    • 提供了任务管理功能:单个线程池也拥有任务队列,在任务队列可以存储多个任务,这是线程无法实现的,并且当任务队列满了之后,可以执行拒绝策略,这些都是线程不具备的。

    4.ScheduledThreadPool

    创建一个可以执行延迟任务的线程池。使用示例如下:

    public static void scheduledThreadPool() {
        // 创建线程池
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
        // 添加定时执行任务(1s 后执行)
        System.out.println("添加任务,时间:" + new Date());
        threadPool.schedule(() -> {
            System.out.println("任务被执行,时间:" + new Date());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
            }
        }, 1, TimeUnit.SECONDS);
    }

    以上程序的执行结果如下图所示:

    从上述结果可以看出,任务在 1 秒之后被执行了,实现了延迟 1s 再执行任务。

    5.SingleThreadScheduledExecutor

    创建一个单线程的可以执行延迟任务的线程池,此线程池可以看作是 ScheduledThreadPool 的单线程池版本。它的使用示例如下:

    public static void SingleThreadScheduledExecutor() {
        // 创建线程池
        ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
        // 添加定时执行任务(2s 后执行)
        System.out.println("添加任务,时间:" + new Date());
        threadPool.schedule(() -> {
            System.out.println("任务被执行,时间:" + new Date());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
            }
        }, 2, TimeUnit.SECONDS);
    }

    以上程序的执行结果如下图所示:

    从上述结果可以看出,任务在 2 秒之后被执行了。

    6.newWorkStealingPool

    创建一个抢占式执行的线程池(任务执行顺序不确定),此方法是 JDK 1.8 版本新增的,因此只有在 JDK 1.8 以上的程序中才能使用。newWorkStealingPool 使用示例如下:

    public static void workStealingPool() {
        // 创建线程池
        ExecutorService threadPool = Executors.newWorkStealingPool();
        // 执行任务
        for (int i = 0; i < 10; i++) {
            final int index = i;
            threadPool.execute(() -> {
                System.out.println(index + " 被执行,线程名:" + Thread.currentThread().getName());
            });
        }
        // 确保任务执行完成
        while (!threadPool.isTerminated()) {
        }
    }

    以上程序的执行结果如下图所示:

    从上述结果可以看出,任务的执行顺序是不确定的,因为它是抢占式执行的。

    7.ThreadPoolExecutor

    ThreadPoolExecutor 是最原始、也是最推荐的手动创建线程池的方式,它在创建时最多提供 7 个参数可供设置。ThreadPoolExecutor 使用示例如下:

    public static void myThreadPoolExecutor() {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10));
        // 执行任务
        for (int i = 0; i < 10; i++) {
            final int index = i;
            threadPool.execute(() -> {
                System.out.println(index + " 被执行,线程名:" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    以上程序的执行结果如下图所示:

    ThreadPoolExecutor 相比于其他创建线程池的优势在于,它可以通过参数来控制最大任务数和拒绝策略,让线程池的执行更加透明和可控,所以在阿里巴巴《Java开发手册》是这样规定的:

    【强制要求】线程池不允许使用 Executors 去创建,而是通过 ThreadPoolExecutor 的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。

    说明:Executors 返回的线程池对象的弊端如下:

    1) FixedThreadPool 和 SingleThreadPool:允许的请求队列长度为 Integer.MAX_VALUE,可能会堆积大量的请求,从而导致 OOM。

    2)CachedThreadPool:允许的创建线程数量为 Integer.MAX_VALUE,可能会创建大量的线程,从而导致 OOM。

    总结

    线程池的创建方式总共有以下 7 种:

    • Executors.newFixedThreadPool:创建一个固定大小的线程池,可控制并发的线程数,超出的线程会在队列中等待。
    • Executors.newCachedThreadPool:创建一个可缓存的线程池,若线程数超过处理所需,缓存一段时间后会回收,若线程数不够,则新建线程。
    • Executors.newSingleThreadExecutor:创建单个线程数的线程池,它可以保证先进先出的执行顺序。
    • Executors.newScheduledThreadPool:创建一个可以执行延迟任务的线程池。
    • Executors.newSingleThreadScheduledExecutor:创建一个单线程的可以执行延迟任务的线程池。
    • Executors.newWorkStealingPool:创建一个抢占式执行的线程池(任务执行顺序不确定)【JDK 1.8 添加】。
    • ThreadPoolExecutor:手动创建线程池的方式,它创建时最多可以设置 7 个参数。

    而线程池的创建推荐使用最后一种 ThreadPoolExecutor 的方式来创建,因为使用它可以明确线程池的运行规则,规避资源耗尽的风险。

    展开全文
  • 创建数组的几种方式

    千次阅读 2020-08-03 23:46:07
    创建数组的几种方式 数组创建有两种格式分别为: 1.动态初始化(指定长度):在创建数组时,直接指定数组中元素的个数。 格式:数据类型[ ] 数组名称 = new 数据类型[ 数组长度] public static void main(String[] ...
  • 创建线程几种方式

    千次阅读 2019-04-12 12:07:59
    创建线程的几种方式: 方式1:通过继承Thread类创建线程 步骤:1.定义Thread的子类,并重写该的run方法,该方法的方法体就是线程需要执行的任务,因此run()方法也被称为线程执行体 2.创建Thread子类的实例,...
  • 创建线程几种方式?3种

    千次阅读 2020-07-20 08:17:10
    1.继承Thread类型重写run 方法 public class ... System.out.println("通过继承Thread重写run方法实现接口!"); } public static void main(String[] args) { ThreadDemoTest threadDemoTest = new T
  • Java 创建类的四种方式

    千次阅读 2020-10-11 21:53:51
    Java 创建类的四种方式 对于上学期已经学习过c++的同学,是不是对另一大编程语言产生了浓厚的兴趣,对于c++的面向对象编程,又和java的面向变量何区别,下面我们从java四种创建对象来说起。 一:new运算的方式创建...
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么? 前言 ...示例:pandas 是基于NumPy 的一工具,该工具是为了解决数据分析任务而创建的。 ...
  • ① 最常见的方式就是直接 new 加构造器的方式创建 ② 变形一:XXX(类名). 静态方法,本质这种方式还去调用中构造器,比如说:单例模式、日历(Calendar) 和一些工具等等。 ③ 变形二:XXXBuilder / ...
  •  总结下来以下4种创建对象的方法:使用 new 关键字调...Java 是面向对象的语言,不可避免的,“对象”这个概念是 Java 语言的核心部分,这里来简单讨论一下在 Java 中创建一般对象的方法。总结下来以下4种创建...
  • 请各位道友,2-3分钟耐心...反射创建对象的几种方式: 1:首先先定义一个Person package com.icitic.reflection; public class Person { public String name; public String age; public String sex; public St
  • C++中关于创建对象的几种方式

    千次阅读 2022-05-03 15:17:21
    C++中创建对象的方式多重的,并不同的创建方式具有不同的意义和生命周期,对于初学者来说还是挺不友好的,今天本初学者抛砖引玉,写一点自己的理解 假如定义了一个classExample ,里面什么都没写。首先就是这...
  • Java快速创建List常用几种方式

    千次阅读 2022-05-23 09:22:27
    1、常规操作 new ArrayList<...2、Arrays工具类创建 List<Integer> list = Arrays.asList(1, 2, 3); Arrays.asList() 方法是 Arrays 的静态方法。这种方式构造的 List 是固定长度的,如果调用 a
  • Spring:创建Bean的几种方式

    万次阅读 多人点赞 2016-06-04 17:42:21
    Spring创建工厂的三种方式
  • java 创建线程的三种方式创建线程池的四种方式

    万次阅读 多人点赞 2019-02-23 21:01:44
    java创建线程的三种方式: 继承Thread类创建线程 实现Runnable接口 通过Callable和Future创建线程 java创建线程池的四种方式: newCachedThreadPool 创建一个可缓存的线程池,如果线程池长度超过处理...
  • 创建对象的5种方式

    千次阅读 2021-03-20 20:44:40
    创建对象的5种方式 1、new关键字 这是我们最常见的创建对象的方式,通过这种方式我们还可以调用任意的构造器(无参的和参的)。 public class Main { public static void main(String[] args) { Person person1 ...
  • 1.继承Thread类型重写run 方法 public class ThreadDemoTest extends Thread{ @Override ... System.out.println("通过继承Thread重写run方法实现接口!"); } public static void main(Strin...
  • 这是最新的大厂面试系列,还原真实场景,提炼出知识点分享给大家。 点赞再看,养成习惯~ 微信搜索【武哥聊编程】,关注这个 Java 菜鸟。...Java 创建线程种方式: 继承Thread,并重写run(...
  • 线程创建常用的四种方式

    千次阅读 2021-03-24 16:28:17
    Java可以用四种方式创建线程,如下所示: 1)继承Thread类创建线程 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程 4)使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的...
  • 线程创建方式和区别 1.继承Thread (1)创建Thread的子类,并重写该的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 (2)创建了Thread子类的实例,即创建了线程对象。...
  • 创建快捷方式几种方法

    千次阅读 2021-07-31 02:00:27
    你知道windows系统中几种方式可以创建桌面快捷方式吗?这里罗列了几个常见的创建桌面快捷方式的方法。方式一: 在电脑桌面(或者资源管理器中)对着空白的地方点击右键,在菜单中找到新建-桌面快捷方式,根据提示...
  • C++对象创建几种方式

    千次阅读 2019-11-21 17:18:16
               C++对象创建几种方式    由于公司的项目众多,且底层由众多团队操刀实施,这样不利于代码的管理和平台的统一性,所以为了将众多的底层C实现的代码整合起来,不得不借助C++的面相对象,...
  • Go语言中创建对象的几种方式

    千次阅读 2020-10-08 14:39:33
    对于Go对象 type Car struct { color string size string } 方式一:使用T{…}方式,结果为值类型 ...以下为创建并初始化 c3 := &Car{"红色", "1.2L"} c4 := &Car{color: "红色"} c5 := Car{color:
  • Java中有几种创建对象的方式(5种)

    千次阅读 2020-07-16 08:55:13
    1、通过new语句实例化一个对象 public static void newCreate() { Person person = new Person("heihei"); System.out.println(person);...通过java.lang.Class中的newInstance()方法来间接的调用构造器
  • 创建线程有几种不同的方式

    千次阅读 2017-04-20 10:45:26
    ①继承Thread(真正意义上的线程),是Runnable接口的实现。 ②实现Runnable接口,并重写里面的run方法。 ③使用Executor框架创建线程池。Executor框架是juc里提供的线程池的实现。 调用线程的start():启动...
  • 创建线程的四种方式

    千次阅读 2019-11-21 00:29:29
    1. 线程的创建有种方式 2. 继承Thread 3. 实现Runnable接口 4.实现Callable接口 5.线程池创建线程 1. 线程的创建有种方式,分别为: 继承Thread 实现Runnable接口 实现Callable接口 使用Executor...
  • 种方式: ①继承Thread(真正意义上的线程),是Runnable接口的实现。 ②实现Runnable接口,并重写里面的run方法。 ③使用Executor框架创建线程池。Executor框架是juc里提供的线程池的实现。调用线程的start...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,186,667
精华内容 474,666
关键字:

创建类有几种方式