Java：多线程的创建

并发和并行：

并行：意思是说多个事件突然在同一时刻发生

并发：说的是多个事件在某一个事件段内同时都在发生

进程和线程：

进程：进程就是一个应用程序的实例，什么意思呢？实际上就是你计算机上运行一个具体的软件，就会开启一个进程。

线程：线程是进程里面更小的执行单位，比如说浏览器里面打开网页，这个就是由线程来完成的，而其中新打开一个网页就相当于新启动了一个线程。

所以，进程里面包含了线程，一个进程可能有多个线程

那么什么是多线程呢？其实就是一个进程里面怎么让多个线程并发的去执行。

创建线程的4种方式：

1.继承Thread类

2.实现runnable接口

3.实现callable接口

4.线程池

使用继承thread类的方式创建线程

首先我们编写也线程类

public class MyThread extends Thread {

    //自己的逻辑业务就写这个里面
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("mythread执行了"+System.currentTimeMillis());
        }
    }
}

我们可以看到这个类继承了Thread类，并且覆写了run方法

现在再写一个测试类

public class MyTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("主线程启动了"+System.currentTimeMillis());
        }
    }
}

我们看到在这个类中我们实例化了一个MyThread类的对象，然后调用了start方法，这样我们就启动了线程，同时我们在下面写了一个主线程的循环用来区分子线程，这里的主线程就是启动main方法的这个线程，子线程就是我们上面自定义的线程。

我们查看结果

可以很明显的发现，这两个程序交替执行了，并且我们发现子线程和主线程执行的时间点有重合的地方，这也就证明了，多线程是可以并发执行的特性。

使用实现runnable接口的方式创建线程

public class MyRunnable implements Runnable {
    /**
     * 逻辑业务就写这个里面
     */
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("runnable执行了"+System.currentTimeMillis()+";执行的次数为"+i);
        }
    }
}

同样我们自定义一个线程类，然后实现runnable接口

我们在测试类种启动线程

public class MyTest {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程执行了"+System.currentTimeMillis());
        }
    }
}

查看结果

仍然是交叉执行的。

使用Callable接口创建线程

public class MyCallable implements Callable<String> {
    //里面是业务逻辑
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("callable执行了"+System.currentTimeMillis());
        }
        return "mycallable执行完毕";
    }
}

我们这里是实现了callable这个接口，然后复写call这个方法，会有一个返回值。这个返回值最后可以获取到。

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

        FutureTask<String> futureTask = new FutureTask<String>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程执行了"+System.currentTimeMillis());
        }

        String res = futureTask.get();
        System.out.println("执行结果是"+res);
    }
}

这里注意看清楚，首先要借助FutureTask这个类，因为这个类是它有如下的继承关系

很明显，这里是继承了来自runnable创建线程的能力。

ok，当创建了一个FutureTask的实例时传入我们自定义的callable实例，然后把FutureTask的实例传入thread的构造函数中，最后还是通过thread的实例启动线程。

使用线程池启动线程：

Java中是使用Executor这个接口来创建线程

这是他们的继承图

使用的时候很简单，我们同样使用上面的runnable作为传入的子线程

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

        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        threadPool.execute(new MyRunnable());
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程执行"+System.currentTimeMillis());
        }
    }
}

这样的话，同样可以创建线程。

总结：

实现接收方式实现多线程的创建和继承Thread类实现多线程有什么优劣

我们推荐使用接口的方式实现多线程的编写。原因如下；

接口是没有单继承的局限的

接口更加适合线程共享一个资源

线程池是只支持放入实现了Runnable类或者Callable类接口的线程的，不支持放入继承Thread类的线程。

在Java每次运行的过程中，至少是要启动两个线程的，一个是主线程，一个是垃圾回收器的线程。

Runnable接口和Callable接口他们有什么区别呢？

两者都可以用来编写多线程，启动线程都需要调用Thread.start()；

不同点在于，实现了Callable接口的线程可以返回执行结果，但是实现了Runnable接口的则不可以返回结果。Callable接口的call方法可以抛出异常，而Runnable接口的run方法则不可以抛出异常。同时Callable接口可以实现对线程的监控，也就是可以取消线程的执行，也可以获取它的返回值，但是Runnable接口的线程就无法实现这个操作。

但是需要注意的一点是，当我们调用futureTask.get()去得到返回结果的时候，主线程是会被阻塞的。