【Java进阶[创建多线程的四种方式]】

创建多线程的四种方式：

最基本的两种：

1）. 继承于Thread类

步骤：

1.创建一个继承于Thread类的子类
2.重写Thread类的run()  -->  将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start()

需要注意的几个问题：
①我们能不能通过直接调用run()的方式启动线程。
这里先补充一点，start方法的作用是先启动当前线程，并执行当前线程类的run方法，如果直接执行run方法，不会创建线程
②不可以让已经start()的线程去执行，会报llegalThreadstateException，必须创建新的线程对象
代码实现：

```java
public class MyThread extends  Thread  {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程1——————"+i);
        }
    }

    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程——————"+i);
        }
    }
}

Thread类的几个重要方法：

我们因为可以通过构造器对线程进行赋值（起名）
yield():释放当前cpu的执行权
join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
sleep(long millitime): 让当前线程“睡眠"指定的millitime毫秒。在指定的millitime 毫秒时间内，当前线程是阻塞状态。
stop()：已过时。当执行此方法时，强制结束当前线程。
interrupt()：中断线程
isAlive():判断当前线程是否存活
getState()：得到当前线程状态
setDaemon（boolean b):设置守护线程 守护线程：伴随其他用户线程运行并消亡
setPriority(int newPriority)：设置线程的优先级 newPriority–>(可以是1-10的数字，MAX_PRIORITY:10,MIN_PRIORITY:1,NORM_PRIORITY:5）
getPriority:获取该线程的优先级

2）.实现Runnable接口

步骤：

1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法: run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象 Thread t = new Thread(new MyThread());
5.通过Thread类的对象调用start()；

两种方式的比较：
开发中:优先选择:实现Runnable接口的方式
原因:
1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况。

3）:实现CallabLe接口。

步骤：
1.创建一个实现Callable的实现类
class NumThread implements Callable{
2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask task = new FutureTask(numThread);
5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象， 并调用start()
new Thread(task).start();
6.获取Callable中call方法的返回值：get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum=task.get();

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?

1. call()可以有返回值的。
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的

4）线程池

步骤：
1.提供指定线程数量的线程池

ExecutorService service = Executors.newFixedThreadPool(10);
		//设置属性
		System.out.println(service.getClass());
		ThreadPoolExecutor service1=(ThreadPoolExecutor)service;
		service1.setCorePoolSize(15);
		service1.setKeepAliveTime();
		service1.setMaximumPoolSize(10);

2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象

NumberThread thread = new NumberThread();
		service.execute(thread);//适用于Runnable
		service.execute(thread);//适用于Runnable
		service. submit(Callable callable);//适合使用FCallable

3.关闭连接池

service.shutdown();

package com;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author lz
 * @creat 2020/10/8-12:27
 */
//测试线程池
public class TestPool {
    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(10);
        service.execute(new MyThread1());
        service.execute(new MyThread1());
        service.execute(new MyThread1());
        service.execute(new MyThread1());

        service.shutdown();
    }
}

class MyThread1 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}