wen 编程最新 2024-01-31

Java多线程详解总结

一、基本概念

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

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

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

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

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

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

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

2. 并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事

并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事

3. 使用多线程的优点

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

4. 何时需要多线程

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

二、多线程的实现

在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. 线程的优先级

线程的优先级等级

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

方法：

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();

三、线程的生命周期

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

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

四、线程的同步与死锁

多个线程执行的不确定性引起执行结果的不稳定

多个线程对账本的共享，会造成操作的不完整性，会破坏数据

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. 练习

五、线程的通信

使用两个线程交替打印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();

    }
}

六、新增线程创建方式

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();
    }
}

七、面试题

1. Java是如何解决线程安全问题的，有几种方式？有什么不同？

2. synchronized和Lock的异同？

3. 写一个线程安全的单例模式

4. sleep()和wait()方法的异同

5. 创建线程的方式(四种)？