Java多线程详解总结

时间 2020-07-16

标签 java 多线程详解总结栏目 Java 繁體版

原文原文链接

1、基本概念

程序(program): 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。java

进程(process):是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期面试

运行中的QQ，运行中的MP3播放器
程序是静态的，进程是动态的
进程做为资源分配的单位，系统在运行时会为每一个进程分配不一样的内存区域

线程(thread):进程可进一步细化为线程，是一个程序内部的一条执行路径。安全

若一个进程同一时间并行执行多个线程，就是支持多线程的
线程做为调度和执行的单位，每一个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
一个进程中的多个线程共享相同的内存单元/内存地址空间->它们从同一堆中分配对象，能够访问相同的变量和对象。这就使得线程间通讯更简便、高效。但多个线程操做共享的系统资源可能就会带来安全的隐患。

1. 单核CPU和多核CPU的理解

单核CPU，实际上是一种假的多线程，由于在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，可是收费站只有一个工做人员在收费，只有收了费才能经过，那么CPU就比如收费人员。若是有某我的不想交钱，那么收费人员能够把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。可是由于CPU时间单元特别短，所以感受不出来。
若是是多核的话，才能更好的发挥多线程的效率。（如今的服务器都是多核的）
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。固然若是发生异常，会影响主线程。

2. 并行与并发

并行：多个CPU同时执行多个任务。好比：多我的同时作不一样的事服务器

并发：一个CPU(采用时间片)同时执行多个任务。好比：秒杀、多我的作同一件事网络

3. 使用多线程的优势

提升应用程序的响应。对图形化界面更有意义，可加强用户体验。
提升计算机系统CPU的利用率
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

4. 什么时候须要多线程

程序须要同时执行两个或多个任务
程序须要实现一些须要等待的任务时，如用户输入、文件读写
操做、网络操做、搜索等
须要一些后台运行的程序时

2、多线程的实现

在Java之中，若是要想实现多线程的程序，那么就必须依靠一个线程的主体类（就比如主类的概念同样，表示的是一个线程的主类），可是这个线程的主体类在定义的时候也须要有一些特殊的要求，这个类能够继承Thread类或实现Runnable接口来完成定义。多线程

1. 继承Thread类

定义子类继承Thread类
子类中重写Thread类中的run方法
建立Thread子类对象，即建立了线程对象
调用线程对象start方法：1启动线程，2调用run方法

要想启动线程必须依靠Thread类的start()方法执行，线程启动以后会默认调用了run()方法、并发

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-10 16:58
 */

// 1.
class Mythread extends Thread{

    // 2.
    @Override
    public void run() {
        for (int i = 0; i < 50 ; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":"+i);
            }
        }
    }
}

public class ThreadTest {

    public static void main(String[] args) {
        // 3.
        Mythread mythread = new Mythread();
        //4.
        mythread.start();
        
        // 这个仍然是在main线程中执行
        for (int i = 0; i < 50 ; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":"+i);
            }
        }
    }
}
/*
注意：
1. 若是本身手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
2. run()方法由JVM调用，何时调用，执行的过程控制都有操做系统的CPU调度决定。
3. 想要启动多线程，必须调用start方法。
4. 一个线程对象只能调用一次start()方法启动，若是重复调用了，则将抛出以上 的异常“IllegalThreadStateException”
*/

// 也可使用匿名内部类简单的写
new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0)
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }.start();

2. Thread类的有关方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操做
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static Thread currentThread(): 返回当前线程。在Thread子类中就是this，一般用于主线程和Runnable实现类
static void yield()：线程让步
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
- 若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其余线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
- 低优先级的线程也能够得到执行
static void sleep(long millis)：(指定时间:毫秒)
- 令当前活动线程在指定时间段内放弃对CPU控制,使其余线程有机会被执行,时间到后重排队。
- 抛出InterruptedException异常

/**
 * 测试Thread中经常使用的方法
 * 1. start():启动当前进程，而且调用当前进程的run()方法
 * 2. run()：一般须要重写Thread类中的此方法，将建立的线程要执行的操做声明在这个方法中
 * 3. currentThread(): 静态方法，返回当前代码的线程
 * 4. getName():获取当前线程的名字
 * 5. setName()： 设置当前线程的名字
 * 6. yield(): 释放当前cpu的执行权
 * 7. join(): 在线程A中调用线程B的join()，此时线程A就进入到了阻塞的状态，直到线程B执行完成，线程A才结束阻塞状态
 * 8. sleep(): 让当前的线程睡眠指定的时间
 *
 * @author MD
 * @create 2020-07-10 20:34
 */

class Method extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);

            if (i % 4 == 0)
                yield();

        }
    }


}

public class ThreadMethodTest {
    public static void main(String[] args) {
        Method method = new Method();
        method.setName("线程一：");
        method.start();

        // 给主线程命名
        Thread.currentThread().setName("主线程：");
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);

            if (i == 10) {
                try {
                    method.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

3. 线程的优先级

线程的优先级等级app

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 默认的 main()

方法：ide

getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级

注意：工具

线程建立时继承父线程的优先级
低优先级只是得到调度的几率低，并不是必定是在高优先级线程以后才被调用

mythread.setPriority(Thread.MAX_PRIORITY);
        mythread.start();

        // 设置主线程的优先级，最低
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

4. 实现Runnable接口

定义子类，实现Runnable接口。
子类中重写Runnable接口中的run方法。
经过Thread类含参构造器建立线程对象。
将Runnable接口的子类对象做为实际参数传递给Thread类的构造器中。
调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-10 21:53
 */

// 1. 定义子类，实现Runnable接口。
class Mthread implements Runnable{

//   2. 子类中重写Runnable接口中的run方法。
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() +":"+i);
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        // 3. 经过Thread类含参构造器建立线程对象。
        Mthread mthread = new Mthread();
        // 4. 将Runnable接口的子类对象做为实际参数传递给Thread类的构造器中。
        Thread t1 = new Thread(mthread);
        //5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法
        
        t1.start();


        // 再启动一个线程
        Thread t2 = new Thread(mthread);
        t2.start();

    }
}

5. 比较建立线程的两种方式

多线程的两种实现方式都须要一个线程的主类，而这个类能够实现Runnable接口或继承Thread类，无论使用何种方式都必须在子类之中覆写run()方法，此方法为线程的主方法；
Thread类是Runnable接口的子类，并且使用Runnable接口能够避免单继承局限，以及更加方便的实现数据共享的概念 ,开发中经常使用

class MyThread implements Runnable {	
    @Override
	public void run() { // 线程的主方法
		// 线程操做方法
	}
}
MyThread mt = new MyThread();
new Thread(mt).start();

// 
class MyThread extends Thread { 
	@Override
	public void run() { // 线程的主方法
		// 线程操做方法
	}
}
MyThread mt = new MyThread();
mt.start();

3、线程的生命周期

要想实现多线程，必须在主线程中建立新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中一般要经历以下的五种状态：

新建：当一个Thread类或其子类的对象被声明并建立时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具有了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并得到CPU资源时,便进入运行状态， run()方法定义了线程的操做和功能
阻塞：在某种特殊状况下，被人为挂起或执行输入输出操做时，让出 CPU 并临时中止本身的执行，进入阻塞状态
死亡：线程完成了它的所有工做或线程被提早强制性地停止或出现异常致使结束

4、线程的同步与死锁

多个线程执行的不肯定性引发执行结果的不稳定

多个线程对帐本的共享，会形成操做的不完整性，会破坏数据

1. 同步问题

模拟火车站售票程序，开启三个窗口售票

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-11 9:25
 */
class Window implements Runnable{

    private int ticket = 100;
    @Override
    public void run() {
        while (true){
			try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (ticket > 0){
                System.out.println(Thread.currentThread().getName() +"：卖票，票号为" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

public class WindowTest {

    public static void main(String[] args) {
        Window w = new Window();

        new Thread(w, "窗口1").start();
        new Thread(w, "窗口2").start();
        new Thread(w, "窗口3").start();
    }
}

问题的缘由：

当多条语句在操做同一个线程共享数据时，一个线程对多条语句只执行了一部分，尚未执行完，另外一个线程参与进来执行。致使共享数据的错误。

解决办法：

对多条操做共享数据的语句，只能让一个线程都执行完，在执行过程当中，其余线程不能够参与执行。

在程序之中就能够经过两种方式完成：一种是同步代码块，另一种就是同步方法。最后还有新增的Lock锁

2. 同步代码块

使用synchronized关键字定义的代码块就称为同步代码块，可是在进行同步的操做之中必须设置一个要同步的对象，而这个对象应该理解为当前对象：this，必须保证惟一

//同步代码块： 
synchronized (对象){ 
// 须要被同步的代码； 
}
//synchronized还能够放在方法声明中，表示整个方法为同步方法。 
//例如： 
public synchronized void show (String name){
…. 
}

操做共享数据的代码，就是须要同步的代码

共享数据：多个线程共同操做的变量

使用同步代码块解决实现Runnable接口的方式的线程安全问题

多个线程要公用一把锁，这里用的是this，由于是实现这个接口，后面就new了一个对象

/**
 * @author MD
 * @create 2020-07-11 9:25
 */

class Window implements Runnable{

    private int ticket = 100;
    @Override
    public void run() {
        while (true){

            synchronized (this){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


                if (ticket > 0){
                    System.out.println(Thread.currentThread().getName() +"：卖票，票号为" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }

        }
    }
}

public class WindowTest {

    public static void main(String[] args) {
        Window w = new Window();

        new Thread(w, "窗口1").start();
        new Thread(w, "窗口2").start();
        new Thread(w, "窗口3").start();
    }
}

同步的方式，解决了线程安全的问题

可是操做同步代码的时候，只能有一个进程参与，其余的进程等待，至关于一个单线程的过程，这个时候效率低

使用同步代码块解决继承Thread类的方式的线程安全问题

这里的同步锁不能再用this了，由于后面new了多个对象

注意声明为静态的

class Window2 extends Thread {
    // 这里要注意声明为静态的
    private static int ticket = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while (true) {
			// 也能够写成这样
            //  synchronized (Window2.class)
            synchronized (obj){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest2 {

    public static void main(String[] args) {
        Window2 w1 = new Window2();
        Window2 w2 = new Window2();
        Window2 w3 = new Window2();

        w1.setName("窗口1");
        w1.start();

        w2.setName("窗口2");
        w2.start();
        w3.setName("窗口3");
        w3.start();
    }
}

3. 同步方法

若是操做共享数据的代码完整的声明在一个方法中，能够将这个方法声明为同步的，这个方法就是同步方法

同步方法仍然涉及到同步监视器，只是不须要咱们显示的声明
非静态的方法，同步监视器就是this，静态的方法同步监视器就是当前类自己

使用同步方法解决实现Runnable接口的线程问题

将方法声明为同步就行使用synchronized

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-11 10:32
 */

class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    // 直接把这个方法声明为这个就能够了 
    // 这个同步监视器就是this
    public synchronized void show(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
            ticket--;
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        new Thread(w, "窗口1").start();
        new Thread(w, "窗口2").start();
        new Thread(w, "窗口3").start();
    }
}

使用同步方法解决继承Thread的线程问题

将方法声明为同步使用synchronized，而且该方法为静态的使用static

package com.atguigu.java;

/**
 * @author MD
 * @create 2020-07-11 10:39
 */

class Window4 extends Thread {
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    // 此时的同步锁是当前的类
    private static synchronized void show(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "：卖票，票号为" + ticket);
            ticket--;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("窗口1");
        w1.start();

        w2.setName("窗口2");
        w2.start();
        w3.setName("窗口3");
        w3.start();
    }
}

4. 死锁

同步就是指一个线程要等待另一个线程执行完毕才会继续执行的一种操做形式，可是若是在一个操做之中都是在互相等着的话，那么就会出现死锁问题。

面试题：请问多个线程操做同一资源的时候要考虑到那些，会带来那些问题？

多个线程访问同一资源的时候必定要考虑到同步的问题，可是过多的同步会带来死锁。

package com.atguigu.java1;

/**
 * @author MD
 * @create 2020-07-11 11:01
 */
public class ThreadTest {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();

    }
}

5. 解决线程安全问题的方式三：Lock锁 ----JDK5.0 新增

实例化ReentrantLock
调用锁定方法lock()
调用解锁方法 unlock()

class A{
private final ReentrantLock lock = new ReenTrantLock(); 
    public void m(){ 
        lock.lock(); 
        try{ 
            //保证线程安全的代码; 
        } 
        finally{ 
            lock.unlock();  
        } 
    }
}
//注意：若是同步代码有异常，要将unlock()写入finally语句块

面试题：synchronized和Lock的异同

Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了做用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。而且具备更好的扩展性（提供更多的子类）
优先使用顺序： Lock ------> 同步代码块（已经进入了方法体，分配了相应资源）--->同步方法（在方法体以外）

注意：若是是使用继承Thread的方式，lock锁得加一个static，这样才能保证是同一把锁

package com.atguigu.java1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author MD
 * @create 2020-07-11 16:00
 */

class Window implements Runnable{

    private int ticket = 100;

    // 1. 实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                // 2. 调用锁定方法lock()
                lock.lock();
                if (ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + " :售票，票号为：" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                //3. 调用解锁方法 unlock()
                lock.unlock();
            }

        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        new Thread(w1,"窗口1").start();
        new Thread(w1,"窗口2").start();
        new Thread(w1,"窗口3").start();

    }
}

如何解决线程安全问题？有几种方式？

同步机制，三种方式

6. 练习

5、线程的通讯

使用两个线程交替打印1-100

package com.atguigu.java2;

/**
 * @author MD
 * @create 2020-07-11 16:44
 */

class Number implements Runnable{

    private int number = 1;
    @Override
    public void run() {
        while (true){

            synchronized (this){

                notify();

                if (number <= 100){
                    System.out.println(Thread.currentThread().getName() + " : "+number);
                    number++;

                    // 使得调用wait()方法的线程进入到了阻塞状态
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }


        }

    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number n = new Number();
        new Thread(n,"A").start();
        new Thread(n,"B").start();
    }
}

wait() 与 notify() 和 notifyAll()

wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其余线程调用notify()或notifyAll()方法唤醒，唤醒后等待从新得到对监视器的全部权后才能继续执行。
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的全部线程结束等待.

注意

这三个方法只有在synchronized方法或synchronized代码块中才能使用，不然会报 java.lang.IllegalMonitorStateException异常。
由于这三个方法必须有锁对象调用，而任意对象均可以做为synchronized的同步锁，所以这三个方法在Object类中声明

1. wait() 方法

在当前线程中调用方法：对象名.wait()
使当前线程进入等待（某对象）状态，直到另外一线程对该对象发出 notify (或notifyAll) 为止。
调用方法的必要条件：当前线程必须具备对该对象的监控权（加锁）
调用此方法后，当前线程将释放对象监控权，也就是释放当前的锁，而后进入等待
在当前线程被notify后，要从新得到监控权，而后从断点处继续代码的执行。

2. notify()/notifyAll()

在当前线程中调用方法：对象名.notify()
功能：唤醒等待该对象监控权的一个/全部线程。
调用方法的必要条件：当前线程必须具备对该对象的监控权（加锁）

3. 面试题：sleep()和wait()方法的异同

均可以使当前的进程进入到阻塞状态
不一样点
- 两个方法声明的位置不一样，sleep()是在Thread类中声明的，wait()方法是在Object类中声明的
- 调用的范围不一样，sleep()能够在任何须要的场景下调用，wait()必须在同步代码块或同步方法中调用
- 关因而否释放同步监视器：若是两个方法都是使用在同步代码块中，那么sleep()方法不会释放锁，而wait()方法会释放锁

4. 生产者消费者问题

package com.atguigu.exer;

/**
 * @author MD
 * @create 2020-07-11 17:14
 */
class Clerk{

    private int productCount = 0;
    // 生产产品
    public synchronized void produceProduct() {
        if (productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + "：开始生产第 "+productCount+"个产品");

            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 消费产品
    public synchronized void consumeProduct() {
        if (productCount > 0){
            System.out.println(Thread.currentThread().getName() +"：开始消费产品第" + productCount+"个产品");
            productCount--;

            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


// 生产者
class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {

        System.out.println(getName()+": 开始生成产品");

        while (true){
            
            clerk.produceProduct();
        }
    }
}

// 消费者
class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {

        System.out.println(getName()+": 开始消费产品");
        
        while (true){
            clerk.consumeProduct();
        }
    }
}


public class ProdectTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");
        p1.start();
        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        c1.start();

    }
}

6、新增线程建立方式

1. 实现Callable接口

与使用Runnable相比， Callable功能更强大些

相比run()方法，能够有返回值
方法能够抛出异常，被外面的操做捕获，获取异常信息
支持泛型的返回值
须要借助FutureTask类，好比获取返回结果

具体步骤以下：

package com.atguigu.java2;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author MD
 * @create 2020-07-11 17:43
 */

// 1. 建立一个实现Callable接口的实现类
class NumThread implements Callable{

    //2. 实现call()方法，将此线程须要执行的操做声明在call()方法中
    @Override
    public Object call() throws Exception {

        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                sum += i;
            }
        }

        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3. 建立Callable接口实现类的对象
        NumThread numThread = new NumThread();

        // 4. 将Callable接口实现类的对象做为参数传递到FutureTask构造器中，建立FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        //5. 将FutureTask的对象做为参数传递到Threa类的构造器中，建立Thread对象，并调用start()方法
        new Thread(futureTask).start();

        //6. 若是须要返回值就写下面的get()方法，
        try {
            // get()返回值就是FutureTask构造器参数Callable实现重写call()的返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2. 使用线程池

背景：常常建立和销毁、使用量特别大的资源，好比并发状况下的线程，对性能影响很大。

思路：提早建立好多个线程，放入线程池中，使用时直接获取，使用完放回池中。能够避免频繁建立销毁、实现重复利用。相似生活中的公共交通工具。

好处：

提升响应速度（减小了建立新线程的时间）
下降资源消耗（重复利用线程池中线程，不须要每次都建立）
便于线程管理：corePoolSize：核心池的大小，maximumPoolSize：最大线程数，keepAliveTime：线程没有任务时最多保持多长时间后会终止

package com.atguigu.java2;

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

/**
 * @author MD
 * @create 2020-07-11 18:06
 */

class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+ " : "+i );
            }

        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName()+ " : "+i );
            }

        }
    }
}


public class ThreadTool {
    public static void main(String[] args) {
        // 1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        // 设置线程池的属性
        


        //2. 执行指定的线程的操做，须要提供实现Runnable接口或实现Callable接口
        // 适合用于Runnable
        service.execute(new NumberThread());
        service.execute(new NumberThread1());

        // 适合用于Callable
        //service.submit();


        // 3. 最后关闭
        service.shutdown();
    }
}