高并发(2)---创建线程的四种方式_高并发写一个线程-优快云博客

本文链接：https://blog.youkuaiyun.com/sinat_23490433/article/details/122860067

方式1、继承Thread类

1）、创建一个类继承Thread类,重写run方法,将要完成的任务代码写进run()方法中

2）、创建Thread类的子类的对象

3）、调用该对象的start()方法,该start()方法表示先开启线程,然后调用run()方法

实现代码如下：

package com.wzy.day01_createThread;
/**
 * 继承Thread类创建线程
 * */
//第1步、创建类ThreadTest,继承Thread类,然后重写run方法
public class ThreadTest extends Thread {
    @Override
    public void run() {
        //1.1、将要完成的任务写在run()方法中
        System.out.println(Thread.currentThread().getName()+"输出的结果");
    }

    public static void main(String[] args) {
        //第2步、创建Thread类的子类对象ThreadTest
        ThreadTest threadTest=new ThreadTest();
        //为线程设置名称
        threadTest.setName("线程1");
        //第3步、调用该对象的start()方法（该方法表示先开启线程,然后调用run()方法）
        threadTest.start();
    }
}

方式2、实现Runnable接口

实现步骤：

1）、创建一个类,并实现Runnable接口

2）、重写run()方法,将要完成的任务代码写入run()方法中

3）、创建实现Runnable接口的类对象,将该对象当作Threa类的构造方法中的参数传进去

4）、使用Thread类的构造方法创建一个对象,并调用start()方法即可运行该线程

实现代码如下：

package com.wzy.day01_createThread;
/**
 * 实现Runnable接口,创建线程
 * */
//第1步、创建类RunnableTest，实现Runnable接口
public class RunnableTest implements Runnable {
    //第2步、重写run()方法,将要完成的任务代码写进run()方法中
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"输出的结果");
    }

    public static void main(String[] args) {
        //第3步、创建实现Runnable接口的类对象RunnableTest
        RunnableTest runnableTest=new RunnableTest();
        new Thread(runnableTest,"线程2").start();
    }
}

方式3、实现Callable接口和Future

实现步骤：

1）、创建一个类并实现Callable接口

2）、重新call()方法,将要完成的任务的代码写进call()方法中,需要注意的是call()方法有返回值,并且可以抛出异常。

3）、如果想要获取运行该线程后的返回值,需要创建Future接口的实现类的对象,即FutureTask类的对象,调用该对象的get()方法就可以获取call()方法的返回值

4）、使用Thread类的有参构造器创建对象,将FutureTask类的对象当作参数传进去,然后调用start()方法开启并运行该线程

实现代码如下：

package com.wzy.day01_createThread;

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

/**
 * 实现Callable接口,创建多线程
 * */
//第1步、创建一个类CallableTest，实现Callable接口，需要返回String类型
public class CallableTest implements Callable<String> {
    //第2步、重写call()方法,将要完成的任务代码写进call()方法中
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"输出的结果");
        return Thread.currentThread().getName()+":"+"返回的结果";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //第3步、想要获取运行该线程后的返回值,需要创建Future接口的实现类的对象FutureTask类
        FutureTask<String> task=new FutureTask<String>(new CallableTest());
        //开启线程
        new Thread(task,"线程3").start();
        //第4步、获取call()方法的返回值,即线程运行结束后的返回值
        String result=task.get();
        System.out.println(result);
    }
}

执行结果如下：

方式4、基于线程池

步骤

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

2）、调用线程池中的execute()方法执行由Runnable接口创建的线程

3）、调用submit()方法执行由实现Callable接口创建的线程

4）、调用线程池中的shutdown()方法关闭线程池

实现代码如下：

package com.wzy.day01_createThread;

import java.util.concurrent.*;

/**
 * 创建线程的第四种方式：使用线程池创建
 * */
public class ThreadPoolTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //第1步、使用Executors类中的newFixedThreadPool(int num)创建一个线程数量为num的线程池
        ExecutorService executorService= Executors.newFixedThreadPool(2);
        //第2步、调用线程池中的execute()方法执行由Runnable接口创建的线程
        executorService.execute(new ThreadDemo1());
        //2.1、调用submit()方法执行由实现Callable接口创建的线程
        Future<String> task=executorService.submit(new ThreadDemo2());
        //获取call()方法的返回值
        String result=task.get();
        System.out.println(result);
        //第3步、关闭线程池
        executorService.shutdown();
    }
}
//实现Runnable接口的线程
class ThreadDemo1 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"输出的结果");
    }
}
//实现Callable接口的线程
class ThreadDemo2 implements Callable<String>{
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"输出的结果");
        return "我是有返回值的";
    }
}

总结：

1）、继承Thread类实现的线程

编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程；缺点是：线程类已经继承了Thread类,所以不能再继承其它父类。

2）、实现Runnable和Callable接口创建的多线程

采用实现接口的方式,还可以继承其它类,在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将cpu、代码和数据分开。

缺点是：如果要访问当前线程,则必须使用Thread.currentThread()方法

3）、Runnable和Callable的区别

runnable接口定义的run()方法,callable接口定义的是call()方法

run方法没有返回值,call方法必须有返回值

run方法无法抛出异常,call方法可以抛出checked exception

callable和Runnable都可以用于executors,而Thread类只支持Runnable

4）、一般推荐使用线程池创建多线程