Java 多线程

多线程

基本概念：程序、进程、线程

程序(program)

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

进程(process)

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

如：运行中的QQ，运行中的MP3播放器。

程序是静态的，进程是动态的。

进程作为资源分配的单位，系统在运行是会为每个进程分配不同的内存区域。

线程(thread)

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

单核CPU和多核CPU的理解

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然多个车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来差别。

如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）。

一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

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

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

多线程的优点

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

线程的创建和使用

线程的创建和启动：方式一

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
Thread类的特性

每个线程都是通过某个特定Thread对选哪个的 run() 方法来完成操作的，经常把run()方法的主体成为线程体。

通过改Thread对象的 start() 方法来启动这个线程，而非直接调用 run() 。

/**
 *多线程的创建，方式一：继承于Thread类
 * 1. 创建一个继承于Thread类的子类
 * 2. 重写Thread类的run()   --> 将此线程要执行的程序声明在run() 中
 * 3. 创建Thread类的子类对象
 * 4. 通过此对象调用start()
 *
 * 例子：遍历100以内的所有的偶数
 */

// 1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
    // 2. 重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        // 3. 创建Thread类的子类对象
        MyThread t1 = new MyThread();
        // 4. 通过此对象调用start()：1.启动当前线程；2.调用当前线程的run()
        t1.start();

        // 如下方法仍在main线程中执行的
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i + "*********");
            }
        }
    }
}

同一个操作实现多线程：多创建Thread类的子类对象

想实现多个操作：创建多个Thread子类对象

问题：

        // 问题一：不能通过直接调用run()的方式启动线程。
				t1.run();
        // 问题二：在此启动一个线程，不可以在此执行已经start() 的线程。报错
				t1.start();
        // 需要重新创建一个线程对象
        MyThread t2 = new MyThread();
        t2.start();

拓展：

Thread.currentThread().getName()//线程号声明
System.out.println(Thread.currentThread().getName() + ":" + i + "偶数");
System.out.println(Thread.currentThread().getName() + ":" + i + "奇数");

输出：
	Thread-0:4偶数
	Thread-1:7奇数

Thread 类的有关方法

start()：启动当前线程：调用当前线程的run()。
run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
currentThread()：静态方法，返回执行当前代码的线程。如果是在Thread子类中就直接 this 。
getName()：获取当前线程的名字。
setName()：设置当前线程的名字。
yield()：释放当前CPU的执行权(只是暂时放弃，依然公平竞争)。

暂停当前正在执行对的线程，把执行机会让给优先级相同或更高的线程。

若当前队列中没有同优先级的线程，忽略此方法。
join()：在线程a 中调用线程b 的join()，此时线程a 就进入阻塞状态，直到线程b 完全执行完以后，线程a 才结束阻塞状态。

低优先级的线程也可以获得执行。
sleep(long millis)：让当前线程“睡眠”指定的millis毫秒。在指定的时间内，当前线程是阻塞状态，之间结束后从新排队。抛出InterruptedException异常
isAlive()：判断当前线程是否存活。返回boolean值
stop()：已过时。当执行此方法是，强制结束当前线程。

class MethodTest extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {

                // sleep()
                try {
                    sleep(10);// 强制阻塞一秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
              	// Thread的子类继承父类直接 this
                System.out.println(this.getName() + ":" + i + "偶数");
            }
            // yield()
//            if(i % 20 == 0){
//                this.yield();
//            }

        }
    }

    // 通过构造器修改线程名
    public MethodTest(String name) {
        super(name);
    }
}

public class ThreadMethod {
    public static void main(String[] args) {
        MethodTest t1 = new MethodTest("Thread:1");
        // t1.setName("线程一");
        t1.start();

        // 给主线程命名
        Thread.currentThread().setName("主线程");

        for (int i = 0; i < 100; i++) {
            if (i % 2 == 1) {
              	// 不是Thread的子类需要声明才能调用
                System.out.println(Thread.currentThread().getName() + ":" + i + "奇数");
            }
            if (i == 20){   // 线程到i = 20 的时候阻塞
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(t1.isAlive());   // 判断线程是否存活
    }
}

线程的调度

调度策略

时间片
抢占式：高优先级的线程抢占CPU。

Java的调度方法

同优先级线程组成先进先出(先到先服务)，使用时间协同式时间片策略。
对高优先级，使用优先调度的抢占式策略。

线程的优先级

MIN_PRIORITY = 1;
NORM_PRIORITY = 5;
MAX_PRIORITY = 10; --》 默认优先级

如何设置当前线程的优先级：

getPriority()   //获取线程的优先级
setPriority(int p)  //设置线程的优先级

class MethodTest extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(this.getName() + ":" + this.getPriority() + "\t" + i + "偶数");
            }
        }
    }

    // 通过构造器修改线程名
    public MethodTest(String name) {
        super(name);
    }
}

public class ThreadMethod {
    public static void main(String[] args) {
        MethodTest t1 = new MethodTest("线程一");
      
        // 设置分线程优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();

        // 给主线程命名
        Thread.currentThread().setName("主线程");
      	// 设置主线程优先级
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        for (int i = 0; i < 100; i++) {
            if (i % 2 == 1) {
                System.out.println(Thread.currentThread().getName() + ":" + 
                                   Thread.currentThread().getPriority() + "\t" + i + "奇数");
            }
        }
    }
}

输出：
  线程一:10	0偶数
	主线程:1	1奇数
	线程一:10	2偶数
	主线程:1	3奇数
  …………

说明：高优先级的线程要抢占低优先级线程CPU的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完成以后，低优先级的线程才执行。

线程的创建和启动：方式二

/**
 * 多线程的创建，方式二：实现Runnable接口
 * 1. 创建一个实现Runnable接口的类
 * 2. 实现类去实现Runnable中的抽象方法：run()
 * 3. 创建实现类的对象
 * 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5. 通过Thread类的对昂调用start()
 */
// 1. 创建一个实现Runnable接口的类
class MThead 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 ThreadTest2 {
    public static void main(String[] args) {
        // 3. 创建实现类的对象
        MThead mThead = new MThead();
        // 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThead);
        t1.setName("线程一");
        // 5. 通过Thread类的对昂调用start() --> 调用了Runnable类型的target的run()
        t1.start();

        // 在启动一个线程
        Thread t2 = new Thread(mThead);
        t2.setName("线程二");
        t2.start();
    }
}

比较创建线程的两种方式

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

联系：public class Thread implements Runnable
相同点：两种方式都需要重写 run() ，将线程要执行的逻辑声明在 run()中。

补充：

Java中的而线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的，通过在start() 方法钱调用。Thread。setDaemon(true) 可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将推出。
形象理解：兔死狗烹，鸟尽弓藏。

线程的声明周期

JDK中用Thread.State类定义了线程的几种状态

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

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

线程的生命周期

线程的同步

问题的提出

多个线程执行的不确定性引起执行结果的不稳定。
多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

例题：

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

class Window2 implements Runnable{

    private int ticket = 20;

    @Override
    public void run() {
        while (true){
            if (ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":" + ticket);
                ticket--;
            } else{
                break;
            }
        }
    }
}
public class WindowTest2 {
    public static void main(String[] args) {
        Window2 window2 = new Window2();

        Thread t1 = new Thread(window2);
        Thread t2 = new Thread(window2);
        Thread t3 = new Thread(window2);

        t1.setName("一号窗口");
        t2.setName("二号窗口");
        t3.setName("三号窗口");

        t1.start();
        t2.start();
        t3.start();
    }
}

问题：卖票过程中，出现了重票、错票 --> 出现了线程的安全问题
问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

输出结果：

二号窗口:20
三号窗口:20
一号窗口:20
二号窗口:17
三号窗口:17
一号窗口:15
二号窗口:14
三号窗口:13
...

多线程出现了安全问题

问题的原因：

当多个语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进行来执行。导致共享数据的错误。
解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

synchronized 的使用方法

Java对于多线程的安全问题提供了专业的解决方式：同步机制

1. 同步代码块

synchronized(同步监视器){
 // 需要被同步的代码
}

说明：

操作共享数据的代码，就是需要被同步的代码
1. 共享数据：多个线程共同操作的变量，比如：ticket就是共享数据。
  
  同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
  
  要求：多个线程必须要公用一把锁。

2. 同步机制中的锁

同步锁机制：

在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
注意：任何一个类的对象，都可以充当锁。

必须确保共享同一个资源的多个线程共用一把锁！
补充：在实现Runnable接口创建多个线程的方式中，我们可以考虑使用this充当同步监视器。

在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器（类名.class）

class Window2 implements Runnable{

    // 三个线程创建的同一个 Window对象所以 资源共享的
    private int ticket = 20;
    Object obj = new Object();
  
    @Override
    public void run() {
        while (true) {
            // 通过阻塞将原本小概率的出错调大
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(obj) { // 设置同步锁
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                    } else {
                        break;
                }
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 window2 = new Window2();

        Thread t1 = new Thread(window2);
        Thread t2 = new Thread(window2);
        Thread t3 = new Thread(window2);

        t1.setName("一号窗口");
        t2.setName("二号窗口");
        t3.setName("三号窗口");

        t1.start();
        t2.start();
        t3.start();
    }
}
输出：
  二号窗口:20
	一号窗口:19
	三号窗口:18
	二号窗口:17
  ……

解决问题：程序只执行某一个线程
方法一：增加ticket数或者增大sleep数（不推荐）
方法二：在synchronized同步方法或同步块之前再增加一个sleep方法:

结果与猜想：与CPU性能有关。
方法二：当sleep在synchronized同步方法或同步块之外的时候,三个线程都有执行,是因为sleep方法会给其他线程运行的机会,而不管其他线程的优先级,(但在synchronized同步方法里的sleep,由于被锁住所以没有优先级之说,也就是说synchronized同步方法里的sleep失效了）

分析同步原理

3. 同步方法

继承Thread类的方法

class Window4 extends Thread {
    // 共享一个静态变量，static全局变量只有一份
    private static int ticket = 100;    // 解决线程资源共享

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

    public static synchronized void show() { // 同步监视器：Window4.class
//    public synchronized void show(){  // 同步监视器：t1，t2，t3.此种解决方式是错误的
        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("一号窗口");
        w2.setName("二号窗口");
        w3.setName("三号窗口");

        w1.start();
        w2.start();
        w3.start();
    }
}

实现Runnable接口的方法

class Window3 implements Runnable {

    private int ticket = 100;

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

    public synchronized void show() {    // 同步监视器：this
//        synchronized(this){
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":" + ticket);
            ticket--;
        }
//        }
    }
}

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

        Thread t1 = new Thread(window3);
        Thread t2 = new Thread(window3);
        Thread t3 = new Thread(window3);

        t1.setName("一号窗口");
        t2.setName("二号窗口");
        t3.setName("三号窗口");

        t1.start();
        t2.start();
        t3.start();
    }
}

关于同步方法的总结：

同步方法仍然涉及到同步监视器，只是不需要我们显式声明。
静态的同步方法，同步监视器是：当前类本身（类名.class）

非静态的同步方法，同步监视器是：this。

4. 线程的死锁问题

死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。(两个不同类的对象作为同步监视器，两个线程，一个先调用a在调用b，另一个先调用b后调用a，就会出现死锁。)

出现死锁后，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
解决办法

专门的算法、原则。

尽量减少同步资源的定义。

尽量避免嵌套同步。

Lock(锁)

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

class A {
    private final ReentrantLock lock = new ReenTrantLock();

    public void m() {
        lock.lock();
        try {
					//处理任务;
        } finally {
            lock.unlock();// 释放锁
        }
    }
}

注意：如果同步代码有异常，要将unlock()写入finally语句块

class Window implements Runnable {
    private int ticket = 20;
    // 1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            // 2.调用lock()
            lock.lock();
            try {
                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 window = new Window();

        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

        t1.setName("一号窗口");
        t2.setName("二号窗口");
        t3.setName("三号窗口");

        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized 与 Lock 的对比
1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放。
2. Lock只有代码块锁，synchronized有代码块锁和方法锁。
3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

优先使用顺序： Lock --> 同步代码块（已经进入了方法体，分配了相应资源）  同步方法（在方法体之外）

面试题：synchronized 与 Lock 的异同？

相同：二者都可以解决线程安全问题。

不同：synchronized机制在执行完相应的同步代码以后，自动地释放同步监视器。
Lock需要手动的启动同步 " lock() "，同时结束同步也需要手动的实现 “ unlock() ”

线程的通信

**wait() 与 notify() 和 notifyAll() **

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

说明：

wait() 与 notify() 和 notifyAll() 三个方法必须使用在同步代码块或同步方法中。

wait() 与 notify() 和 notifyAll() 三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则报IllegalMonitorStateException 异常。

wait() 与 notify() 和 notifyAll() 三个方法定义在java.lang.Object类中。

wait(): 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器(锁)。

notify(): 一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先优先级高的线程

notifyAll(): 一旦执行此方法，就会唤醒所有被wait的现象。

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++;
                    // sleep 相当于在厕所内睡着了，门还是锁着的，wait相当于出去等，位置让出来
                    try {
                        wait();// 会释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

public class Communication {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("三张");
        t2.setName("四李");

        t1.start();
        t2.start();
    }
}

面试题：sleep() 和 wait() 的异同

相同点：一旦执行方法，都可以是当前的线程进入阻塞状态。

不同点：

位置不同：Thread类中声明sleep(),Object类中声明wait()。

调用的要求不同：sleep() 可以在任何需要的场景下调用。wait() 必须使用在同步代码或同步代码块中。

在同步代码块或同步方法中 sleep 会释放锁，wait 不会。

经典例题

/**
 * 线程通信应用：经典例题：生产者/消费者问题
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
 * 取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产
 * 更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续
 * 生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知
 * 消费者来取走产品。
 *
 */
class shouhuo {
    private int pin = 0;

    public synchronized void chan() {
        if (pin >= 20) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            pin++;
            System.out.println(Thread.currentThread().getName() + "生产了" + pin + "个产品。");
            notifyAll();
        }
    }

    public synchronized void fei() {
        if (pin <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println(Thread.currentThread().getName() + "消费了" + pin + "个产品。");
            pin--;
            notifyAll();
        }
    }
}

class sheng implements Runnable {// 生产
    shouhuo shou;

    public sheng(shouhuo shou) {
        this.shou = shou;
    }

    @Override
    public void run() {
        System.out.println("开始生产……");
        while (true) {
            try {
                Thread.sleep((int) Math.random() * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            shou.chan();
        }
    }
}

class xiao implements Runnable {// 消费
    shouhuo shou;

    public xiao(shouhuo shou) {
        this.shou = shou;
    }

    @Override
    public void run() {
        System.out.println("开始消费……");
        while (true) {
            try {
                Thread.sleep((int) Math.random() * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            shou.fei();
        }
    }
}

public class ProductTest2 {
    public static void main(String[] args) {
        shouhuo shouhuo = new shouhuo();
        Thread t1 = new Thread(new sheng(shouhuo));
        Thread t2 = new Thread(new xiao(shouhuo));

        t1.setName("生产员：");
        t2.setName("==消费者：");

        t1.start();
        t2.start();
    }
}

JDK5.0新增线程创建方式

新增方式一：实现Callable接口

Future接口

可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。

FutrueTask是Futrue接口的唯一的实现类。

FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值

// 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) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum; // 如果不要返回值 返回 null 即可。
    }
}

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的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            // 6.获取Callable中call方法的返回值。
            // get() 返回值即为FutureTask构造器参数Callable实现类重写的call() 的返回值
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

与使用Runnable相比，Callable功能更强大些。
1. 相比run()方法，可以有返回值。
2. 方法可以抛出异常。
3. 支持泛型的返回值。
4. 需要借助FutureTask类，比如获取返回结果。

新增方式二：使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
1. 提高响应速度（减少了创建新线程的时间）
2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3. 便于线程管理
  - corePoolSize：核心池的大
  - maximumPoolSize：最大线程数
  - keepAliveTime：线程没有任务时最多保持多长时间后会终止
  - …

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 NumberThread2 implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 20; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        // 1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; // 详细转型
        // System.out.println(service.getClass());
        // 设置线程池的属性
        /*ExecutorService 是接口，里面的实行都是常量和抽象方法，所以想调用它的实现类对象，向下转型后就可以了*/
        service1.setCorePoolSize(15);
        service1.setCorePoolSize(20);

        // 2. 执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        // service.execute(new NumberThread());  // 适用于Runnable
        // service.submit(n1);                  // 适用于Callable

        NumberThread2 n1 = new NumberThread2();
        Future sum = service.submit(n1);// 适用于Callable
        try {
            System.out.println("获取返回值：" + sum.get()); // 获取返回值
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        // 关闭连接池
        service.shutdown();
    }
}

线程池相关API

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行 Runnable
- Future submit(Callable task)：执行任务，有返回值，一般又来执行 Callable
- void shutdown() ：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。