线程的创建

线程的创建分为4种方式：

1.继承Thread类，重写run方法

启动线程是调用start方法，这样会创建一个新的线程，并执行线程的任务。
如果直接调用run方法，这样会让当前线程执行run方法中的业务逻辑，但不能得到多线程的效果。

public class MiTest {

    public static void main(String[] args) {
        MyJob t1 = new MyJob();
        t1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main:" + i);
        }
    }

}
class MyJob extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyJob:" + i);
        }
    }
}

2.实现Runnable接口 重写run方法

public class MiTest {

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        t1.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main:" + i);
        }
    }

}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyRunnable:" + i);
        }

    }
}

最常用的方式：

• 匿名内部类方式

Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("匿名内部类:" + i);
        }
    }
});

• lambda方式

Thread t2 = new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        System.out.println("lambda:" + i);
    }
});

3.实现Callable 重写call方法，配合FutureTask

Callable一般用于有返回结果的非阻塞的执行方法

同步非阻塞。
FutureTask底层实现了Ruunable接口，run()中调用了call()

public class MiTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1. 创建MyCallable
        MyCallable myCallable = new MyCallable();
        //2. 创建FutureTask，传入Callable
        FutureTask futureTask = new FutureTask(myCallable);
        //3. 创建Thread线程
        Thread t1 = new Thread(futureTask);
        //4. 启动线程
        t1.start();
        //5. 做一些操作
        //6. 要结果
        Object count = futureTask.get();
        System.out.println("总和为：" + count);
    }
}

class MyCallable implements Callable{

    @Override
    public Object call() throws Exception {
        int count = 0;
        for (int i = 0; i < 100; i++) {
            count += i;
        }
        return count;
    }
}

4.基于线程池构建线程

线程是非常宝贵的计算资源，在每次需要时创建并在运行结束后销毁是非常浪费系统资源的。我们可以使用缓存策略并通过线程池来创建线程。具体实现过程为创建一个线程池并用该线程池提交线程任务。

ExecutorService threadPool = Executors.newFixedThreadPool(10);
		for (int i = 0; i < 10; i++) {
			//提交多个线程任务并执行
			threadPool.execute(new Runnable(){
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName()+"is running");
				}
			});
		}

总结：这四种方法追其底层，就是只有一种，实现Runable接口

5.相关问题：

(1)Thread类中为什么调用start()方法而不是run()方法

先看start()源码，底层调用start0()，它是一个本地方法

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)    // 判断线程的状态
            throw new IllegalThreadStateException();    // 抛出异常
 
        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);
 
        boolean started = false;
        try {
            start0();    // 在start()方法中调用start0()
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
 
    private native void start0();    // 只定义方法名称没有实现，返回类型native

run()的源码

 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

  原因就是Java以良好的跨平台可移植性著称，而在不同的操作系统之中他的资源调度算法是不同的，但操作系统会提供底层函数来进行资源调度。所以当我们在Java程序中调用start()方法时，然后start()方法会去调用start0()，而start0()只有定义没有实现，那么实现是由谁来做的呢？是JVM来做，JVM会根据用户系统类型实现相应的start0()方法，以此实现多线程。而直接调用run()方法并不能达到此效果。
  run()源码并没有实现多线程，如果是直接调用run()，则是顺序执行的，不是多线程。

(2)实现Callable接口创建线程与实现Runnable接口和继承Thread创建线程有什么区别？

① Callable接口可以有返回值
② Callable接口可以抛出异常
③ 执行方法不同，call()方法和run()方法
如果需要获取一个线程执行完毕的结果, 相比其他方式，使用 Callable 更方便不易出错。比如计算0-100累加的和：

非Callable接口方式：

static class Result {
    public int sum = 0;
    public Object lock = new Object();
}

public static void main(String[] args) throws InterruptedException {
    Result result = new Result();
    Thread t = new Thread() {
        @Override
        public void run() {
            int sum = 0;
            for (int i = 1; i <= 1000; i++) {
                sum += i;
           }
            synchronized (result.lock) {
                result.sum = sum;
                result.lock.notify();
           }
       }
   };
    t.start();
    synchronized (result.lock) {
        while (result.sum == 0) {
        	// 等待 t 线程计算完之后唤醒当前阻塞状态
            result.lock.wait();
       }
        System.out.println(result.sum);
   }
}

虽然这种方式也获取到了线程执行完毕的结果, 但本质上并不是作为返回值的, 而是两个线程修改了同一个变量, 这个变量是 result 类的成员属性, 并且实现的过程比较复杂

所以如果需要获取一个线程执行完毕的结果, 使用 Callable 更方便不易出错

Callable<Integer> callable = new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 1000; i++) {
            sum += i;
        }
        return sum;
   }
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread t = new Thread(futureTask);
t.start();
int result = futureTask.get();
System.out.println(result);