关键词：

public class MyThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread()+ " " + i);
        }
    }
}

public class Main {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();

        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread()+ " " + i);
        }
    }
}

public class MyThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread()+ " " + i);
        }
    }
}

public class Main {

    public static void main(String[] args) {

        MyThread2 mt = new MyThread2();
        Thread t = new Thread(mt);
        t.start();

        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread()+ " " + i);
        }
    }
}

public class MyThread3 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {

        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

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

public class Main {

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

        Callable<Integer> callable = new MyThread3();
        FutureTask<Integer> task = new FutureTask<>(callable);

        new Thread(task).start();
        Integer integer = task.get();
        System.out.println(integer);//输出4590
    }
}

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

Java中创建线程主要有三种方式：一、继承Thread类创建线程类（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。（2）创建Thread子类的实例，即创建了线程... 查看详情

spring中创建bean对象的三种方式以及作用范围

 时间：2020/02/02 一.在spring的xml配置文件中创建bean对象的三种方式：1.使用默认构造函数创建。在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时采用的就是默认构造函数创建bean对象，此... 查看详情

线程的三种创建方式

java中创建线程的方法有三种：1.继承Thread类实现2.实现Runnable接口3.使用Callable和Future创建                      ------------------------继承Thread类创建线程-... 查看详情

js中创建函数的三种方式及区别(代码片段)

1.函数声明functionsum1(n1,n2)returnn1+n2;;2.函数表达式，又叫函数字面量varsum2=function(n1,n2)returnn1+n2;;两者的区别：解析器会先读取函数声明，并使其在执行任何代码之前可以访问；而函数表达式则必须等到解析器执行到它所在的代码行... 查看详情

java多线程实现的三种方式

 JAVA多线程实现的三种方式Java中继承thread类与实现Runnable接口的区别 查看详情

java-多线程-创建线程的三种方式

JAVA-多线程-创建线程的三种方式并发：同一时间只有一条指令在执行，多个进程的指令被快速轮换执行。并行：同一时间有多条指令在多个处理器上运行。进程：每个运行中的程序就是一个进程。线程：线程（Thread）也被称为轻... 查看详情

java多线程的三种实现方式

今天简单说一下Java三种多线程实现方式和区别，主要有实现Runnable、Callable和继承Thread三种方式。实现Runnable的方式这种方式比较常用，当我们的线程类有继承其他的类的情况下（Java不支持类多继承），并且线程任务不需要返回... 查看详情

java创建线程的三种方式

1.继承Runnable接口packagetest;classRunnableDemoimplementsRunnable{privateThreadt;privateStringthreadName;RunnableDemo(Stringname){threadName=name;System.out.println("Creating"+name);}publicvoidrun(){Syste 查看详情

java创建线程的三种主要方式

Java创建线程的主要方式一、继承Thread类创建　　通过继承Thread并且重写其run()，run方法中即线程执行任务。创建后的子类通过调用start()方法即可执行线程方法。　　通过继承Thread实现的线程类，多个线程间无法共享线程类的实... 查看详情

java创建线程的三种方式

http://blog.csdn.net/longshengguoji/article/details/41126119线程的四种创建方式：（1）继承Thread类（2）实现Runnable接口（3）应用程序可通过使用Executor框架来创建线程池（4）实现callable接口线程的几种可用状态（1）新建（2）可运行（3）运... 查看详情

java多线程开启的三种方式

1、继承Thread类，新建一个当前类对象，并且运行其start()方法1packagecom.xiaostudy.thread;23/**4*@desc第一种开启线程的方式5*@authorxiaostudy6*7*/8publicclassDemo1_ThreadextendsThread{910publicvoidrun(){11for(inti=0;i<10;i++){12Syste 查看详情

ajpfx关于java多线程实现的三种方式

JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 1、继承Thread类实现多线程... 查看详情

java多线程实现的三种方式(代码片段)

文章目录实现多线程方式一：继承Thread类方法介绍实现步骤代码演示思考问题实现多线程方式二：实现Runnable接口Thread构造方法实现步骤代码演示实现多线程方式三:实现Callable接口方法介绍实现步骤代码演示三种实现方式... 查看详情

大数据必学java基础（七十六）：创建线程的三种方式(代码片段)

文章目录创建线程的三种方式一、继承Thread类二、实现Runnable接口三、实现Callable接口创建线程的三种方式一、继承Thread类在学习多线程之前，以前的代码是单线程的吗？不是，以前也是有三个线程同时执行的。现在... 查看详情

django中创建对象的三种方法(代码片段)

一、直接创建对象person=Person()person.p_name=‘mozili‘person.save()二、使用create()函数创建person=Person.objects.create(p_name=‘limozi‘,p_age=20,p_sex=False)person.save()returnHttpResponse(‘创建成功！‘)三、在模型中自定义函数创建对象model 查看详情

threadpoolexecutor的三种提交任务方式

学习内容：ExecutorService线程池的应用...1.如何创建线程池...2.调用线程池的方法，获取线程执行完毕后的结果...3.关闭线程...  首先我们先了解一下到底什么是线程池，只有了解了其中的道理，我们才能够进行应用...java.util... 查看详情

java多线程实现的三种方法，附两个线程执行不同的输出

JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。1、继承Thread类实现多... 查看详情

创建线程的三种方式

1、继承Thread类，重写run方法，调用start方法启动线程；packageThread;//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程//总结：注意，线程开启不一定立即执行，由CPU调度执行publicclassthreadDemo1extendsThread@Overridepublicvoi... 查看详情