Java程序员之创建多线程的几种方式（三种方式、七种方法）

线程的三种创建方式：

1.继承Thread实现（两种写法）

写法1：

写法2：

2.实现Runnable接口（三种写法）

1.写法1：实现runnable接口，新建线程

2.写法2：Runnable 匿名内部类

3.写法3：lambda表达式

        3.实现Callable接口（两种写法）

1.写法1：Callable+Future

2.写法2：匿名callable接口

        4.总结

---

线程的三种创建方式：

1.继承Thread实现（两种写法）

写法1：

• 代码如下：

package thread.threaddemo;

/**
 * @Author: wenjingyuan
 * @Date: 2022/11/01/11:13
 * @Description:继承Thread来创建线程
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread mainThread=Thread.currentThread();
        System.out.println("线程名称"+mainThread.getName());
        Thread thread=new MyThread();
        //开启线程
        thread.start();

    }
}

class MyThread extends Thread{
    @Override
    public void run() {
//        //具体的业务代码
//        try {
//            Thread.sleep(1000*60*60);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println("线程的名称"+Thread.currentThread().getName());
    }
}

• 使用jconsloe工具来观察线程

1.那么如何来找到你的jconsole工具？

答：首先你应该找到你的电脑所安装的jdk的环境，在jdk下bin目录下，会有一个jconsole.exe

双击之后选择本地连接选择当前所在的线程，选择不安全的连接即可进入工具进行使用。

点击上方红色圈中的线程选项，即可得到目前线程的一个情况：

写法2：

package thread.threaddemo;

/**
 * @Author: wenjingyuan
 * @Date: 2022/11/01/20:52
 * @Description:继承Thread类，重写run方法
 */
public class ThreadDemo7 {
    public static void main(String[] args) {
       //创建线程并初始化
       Thread thread=new Thread(){
           @Override
           public void run() {
               System.out.println("执行的线程为"+Thread.currentThread().getName());
           }
       };
       thread.start();
    }
}

•  面试问题：启动一个新线程的时候是用run（）还是start（）方法？

       表面上看，我们通过两种方法能够得到同样的结果，但实际上只有start（）能够创建一个新的线程，当我们使用普通的run（）方法的时候，我们只是使用main线程调用了一个普通的方法而已，相反在执行start()的时候，我们才会创建一个新的线程。通过打印线程的名称就可以判断出调用run（）的时候真的没有创建一个新的线程，线程的名字还是主线程的名字。还有一个区别就是，我们的run（）方法作为普通方法可以被调用多次，但是start（）方法可以被调用一次。

• 致命缺点：

Java语言是单继承多实现，如果继承了Thread类，就不可以在继承其他的类了。

---

2.实现Runnable接口（三种写法）

1.写法1：实现runnable接口，新建线程

package thread.threaddemo;

/**
 * @Author: wenjingyuan
 * @Date: 2022/11/01/20:18
 * @Description:实现runnable接口，新建线程
 */
public class ThreadDemo4 {
    public static void main(String[] args) {
        //先创建Runnable
        MyThread2 myThread2=new MyThread2();
        //在创建线程
        Thread thread=new Thread(myThread2);
        //执行线程
        thread.start();
    }
}
class MyThread2 implements Runnable{

    @Override
    public void run() {
        //具体的业务代码
        System.out.println("执行的线程为"+Thread.currentThread().getName());
    }
}

2.写法2：Runnable 匿名内部类

package thread.threaddemo;

/**
 * @Author: wenjingyuan
 * @Date: 2022/11/01/20:30
 * @Description:Runnable 匿名内部类
 */
public class ThreadDemo5 {
    public static void main(String[] args) {
       //匿名内部类
       Thread thread=new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println("执行的线程为"+Thread.currentThread().getName());
           }
       }) ;
       thread.start();
    }
}

3.写法3：lambda表达式

package thread.threaddemo;

/**
 * @Author: wenjingyuan
 * @Date: 2022/11/01/20:38
 * @Description:lambda表达式
 */
public class ThreadDemo6 {
    public static void main(String[] args) {
        //创建线程
        Thread thread=new Thread(()->{
            System.out.println("执行的线程为"+Thread.currentThread().getName());
        });
        //启动线程
        thread.start();
    }
}

• 以上所有线程的创建方式中，都有一个共同的缺点，那就是不带有返回值。也就是说当线程执行结束以后，主线程是没有办法拿到新线程的返回值的。

3.实现Callable接口（两种写法）

1.写法1：Callable+Future

package thread.threaddemo;

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

/**
 * @Author: wenjingyuan
 * @Date: 2022/11/01/21:01
 * @Description:实现callable  新建线程
 */
public class ThreadDemo8 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable=new MyCallable();
        FutureTask<Integer> futureTask=new FutureTask<>(myCallable);
        Thread thread=new Thread(futureTask);
        //启动线程
        thread.start();
        //拿到结果
        int result=futureTask.get();
        System.out.println(Thread.currentThread().getName());
        System.out.println("随机数为"+result);
    }
}
class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        //具体的业务代码
        //随机数0-9
        int random=new Random().nextInt(10);
        System.out.println(Thread.currentThread().getName()+"随机数为"+random);
        return random;
    }
}

2.写法2：匿名callable接口

package thread.threaddemo;

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

/**
 * @Author: wenjingyuan
 * @Date: 2022/11/01/21:25
 * @Description:
 */
public class ThreadDemo9 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask<Integer> futureTask=new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                //具体的业务代码
                //随机数0-9
                int random=new Random().nextInt(10);
                System.out.println(Thread.currentThread().getName()+"随机数为"+random);
                return random;
            }
        });
        Thread thread=new Thread(futureTask);
        //启动
        thread.start();
        int result=futureTask.get();
        System.out.println(Thread.currentThread().getName()+"随机数结果为"+result);
    }
}

4.总结

1.如果你是jdk1.8和之后的版本，不需要返回值的话可以考虑用lambda表达式来创建新线程

2.如果需要返回值可以考虑用最后一种方法匿名callable接口