Java：多线程的创建

╰半夏微凉° 2021-11-22 13:26 295阅读 0赞

# 并发和并行： #

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

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

# 进程和线程： #

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

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

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

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

# 创建线程的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方法的这个线程，子线程就是我们上面自定义的线程。

我们查看结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MTk4NDY3_size_16_color_FFFFFF_t_70][]

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

### 使用实现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());
            }
        }
    }

查看结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MTk4NDY3_size_16_color_FFFFFF_t_70 1][]

仍然是交叉执行的。

### 使用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这个类，因为这个类是它有如下的继承关系

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MTk4NDY3_size_16_color_FFFFFF_t_70 2][]

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

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

### 使用线程池启动线程： ###

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

这是他们的继承图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MTk4NDY3_size_16_color_FFFFFF_t_70 3][]

使用的时候很简单，我们同样使用上面的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()去得到返回结果的时候，主线程是会被阻塞的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MTk4NDY3_size_16_color_FFFFFF_t_70]: /images/20211122/1e448e2e56694a0abb078e872393dca9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MTk4NDY3_size_16_color_FFFFFF_t_70 1]: /images/20211122/a91d4ffe49f64c8ab83310abeb98e5c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MTk4NDY3_size_16_color_FFFFFF_t_70 2]: /images/20211122/9186a10cc035457898d62fdb9ad4b775.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MTk4NDY3_size_16_color_FFFFFF_t_70 3]: /images/20211122/a126ca78be5b49dbaa67f2a815e3fce1.png