线程的创建
多线程:
线程有四种创建方式：
继承Thread，重写run方法
实现Runnable接口
实现Callable接口
线程池
注意： 启动线程就是指请求jvm运行相应的程序
启动线程不代表线程就会立即运行，由线程调度器（scheduler）决定
第一种：
1）继承Thread，并且重写run方法：
重写父类的run()方法
package com.itjh.pojo;
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 200; i++) {
//被调用时获得当前线程的名字，主方法中的`.start()`就表示被调用
System.out.println(getName()+"。。。子线程。。。。。"+i);
}
}
}
2）创建一个主线程：
实例化MyThread类，调用start()方法，意为自动开启线程，并且他会自动去调用MyThread()类中的run()方法
主线程和MyThread子线程的执行顺序与代码放置的顺序是无关的，但是一个方法同一个类中的方法是按照顺序来的，主线程第执行完毕后才会执行.......主方法.......
package com.itjh.Test;
import com.itjh.pojo.MyThread;
public class Test01 {
public static void main(String[] args) {
MyThread myThread=new MyThread();
//给子线程起个名字！！！
myThread.setName("子线1==");
myThread.start();
for (int i = 0; i < 200; i++) {
System.out.println("主线程"+i);
}
System.out.println(".......主方法.......");
}
}
结果大概这样：
主线程196
主线程197
主线程198
主线程199
子线1==。。。子线程。。。。。132
子线1==。。。子线程。。。。。133
子线1==。。。子线程。。。。。134
子线1==。。。子线程。。。。。135
.......主方法.......
子线1==。。。子线程。。。。。136
子线1==。。。子线程。。。。。137
第二种方法：
1）创建MyRunnable类实现Runnable类，并且重写run()方法
package com.one;
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 300; i++) {
System.out.println("子线程实现Runnable第"+i);
}
}
}
2）创建主线程：
先实例化Thread，将MyRunnable传进去，在Thread类中有很多构造方法：
如：
这里我采用第三个构造函数，传进去一个实现类和自定义线程名
import com.one.MyRunnable;
public class MyRunnableTest {
public static void main(String[] args) {
Thread thread=new Thread(new MyRunnable());
thread.start();
for(int i=0;i<300;i++){
System.out.println("主线程第"+i);
}
}
}
结果是乱序的，也可能是顺序的
第三种：
思路：Callable接口要借助于FutureTask类来创建线程，FutureTask继承了Runnable接口,所以，将他放入Thread实例化进行的构造函数传参中，Thread . start()开启线程
创建新的类实现Callable接口，并且重写其中的call()方法：
package com.itjh.pojo;
import java.util.concurrent.Callable;
public class MyCallable implements Callable {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum=sum+i;
}
return sum;
}
}
创建主线程：
package com.itjh.Test;
import com.itjh.pojo.MyCallable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test03 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//先获得的一个自己创建的MyCallable对象，即子线程
MyCallable myCallable=new MyCallable();
//创建FutureTask接收子线程进行管理，并设置管理的子线程的返回值为Integer
FutureTask<Integer> futureTask=new FutureTask(myCallable);
//FutureTask最终继承了Runnable类，所以直接扔进Tread中
Thread thread=new Thread(futureTask);
thread.start();
//用FutureTask的get()方法获得返回值，并打印
Integer i =futureTask.get();
System.out.println(i);
}
}
为什么不直接将Callable实现类放在Thread实例化中呢？为什么要用要借助FutureTask才能创建基于Callable接口的实现类的线程呢？
1、因为Tread构造方法中没有Callable的返回类型
2、FutureTask实现了RunnableFuture接口，而RunnableFuture接口又继承了Runnable接口，在Thread类中有参数类型为Runnable的构造方法，FutureTask类中有参数类型为Callable的构造函数，综上所述，所以要借助FutureTask创建线程
第四种：
线程池
创建线程的各种方法对比：
图片摘自：https://www.bilibili.com/video/BV1ut411T7Yg?p=8