第7章多线程

基本概念
线程的创建方式
线程的生命周期
线程安全
线程通信
生产者消费者问题

基本概念

程序、进程和线程

Java内存结构图

每个线程，拥有自己独立的：栈、程序计数器。
多个线程，共享同一个进程中的结构：方法区、堆。

第7章多线程 - 图3

单核与多核CPU

第7章多线程 - 图4

线程的创建方式

方式1：继承 Thread 类

步骤：
1、创建一个继承于Thread类的子类；
2、重写Thread类的run()，将此线程执行的操作声明在run()中；
3、创建Thread类的子类的对象；
4、通过此对象调用start()。

注意点：

我们不能通过直接调用run()的方式启动线程。
如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()，不可以还让已经start()的线程去执行，会报IllegalThreadStateException。

【示例代码】

// 1. 创建一个继承于Thread类的子类
class MyThread1 extends Thread {
    // 2. 重写Thread类的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类的子类的对象
        MyThread1 t1 = new MyThread1();
        t1.setName("线程1");
        // 4.通过此对象调用start():
        // ①启动当前线程 ② 调用当前线程的run()
        t1.start();
        // 再启动一个线程
        MyThread1 t2 = new MyThread1();
        t2.setName("线程2");
        t2.start();
    }
}

方式2：实现 Runnable 接口

创建步骤
1、创建一个实现了 Runnable 接口的类；
2、实现类去实现 Runnable 中的抽象方法：run()；
3、创建实现类的对象；
4、将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象；
5、通过 Thread 类的对象调用 start()。

【示例代码】

// 1. 创建一个实现了Runnable接口的类
class MyThread 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 ThreadTest {
    public static void main(String[] args) {
        // 3. 创建实现类的对象
        MyThread myThread = new MyThread();
        // 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(myThread);
        t1.setName("线程1");
        // 5. 通过Thread类的对象调用start():
        // ① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();
        // 再启动一个线程：
        Thread t2 = new Thread(myThread);
        t2.setName("线程2");
        t2.start();
    }
}

继承方式与实现方式的比较

开发中优先选择实现Runnable接口的方式。原因：
- 实现的方式没有类的单继承性的局限性。
- 实现的方式更适合来处理多个线程有共享数据的情况。
联系：public class Thread implements Runnable
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。

方式3：实现 Callable 接口

创建步骤
1、创建一个实现Callable接口的实现类；
2、实现call()方法，将此线程需要执行的操作声明在call()中；
3、创建Callable接口实现类的对象，并将此Calllable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象；
4、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法；
5、获取Callable中call()方法的返回值，get()方法的返回值即为FutureTask构造器参数Callable实现类重写的call()方法的返回值。

如何理解实现**Callable**接口的方式创建多线程比实现**Runnable**接口创建多线程方式强大？
1、call()可以有返回值的。
2、call()可以抛出异常，被外面的操作捕获，获取异常的信息。
3、Callable是支持泛型的。

【示例代码】

// 1.创建一个实现Callable的实现类
class NumThread implements Callable<Integer> {
    // 2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Integer 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;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        // 3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        // 4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);
        // 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        try {
            // 6.获取Callable中call方法的返回值
            // get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Integer sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式4：使用线程池

创建步骤
1、提供指定线程数量的线程池；
2、设置线程池的属性；
3、执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象；
4、关闭连接池。

【示例代码】

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);
            }
        }
    }
}
class NumberThread2 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 ThreadPoolTest {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread1());
        service.execute(new NumberThread2());
        //3.关闭连接池
        service.shutdown();

线程的生命周期

线程安全

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

在Java中，我们通过同步机制来解决线程的安全问题，操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率会比较低。

方法1：同步代码块

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

说明：
1、操作共享数据的代码，即为需要被同步的代码。
2、共享数据：多个线程共同操作的变量。
3、同步监视器，俗称：锁。

任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。
在实现Runnable接口创建多线程的方式中，可以考虑使用this或任意的对象变量充当锁。
在继承Thread类创建多线程的方式中，考虑使用当前类或任意的静态的对象变量充当锁。

方法2：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
例如：private static synchronized void show() {...}

说明：
1、同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2、非静态的同步方法，同步监视器是：this。
3、静态的同步方法，同步监视器是：当前类本身。

【示例1：改造单例模式-懒汉式】

class Bank {
    private Bank(){}
    private static Bank instance = null;
    // 方法一：使用同步方法，同步监视器是Bank.class
//    public static synchronized Bank getInstance() {
//        if (instance == null)
//            instance = new Bank();
//        return instance;
//    }
    // 方法二：使用同步代码块
    public static Bank getInstance() {
        // 写法1：效率差
//        synchronized (Bank.class) {
//            if (instance == null)
//                instance = new Bank();
//            return instance;
//        }
        // 写法2：效率稍高
        if (instance == null) {
            synchronized (Bank.class) {
                instance = new Bank();
            }
        }
        return instance;
    }
}

方法3：lock 锁

Lock是JDK5.0新增的新特性。

【示例代码】

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w, "窗口1");
        Thread t2 = new Thread(w, "窗口2");
        Thread t3 = new Thread(w, "窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window implements Runnable {
    private int ticket = 100;
    // 1.实例化ReentrantLock对象
    private ReentrantLock lock = new ReentrantLock(true);
    @Override
    public void run() {
        while (true) {
            try {
                // 2.锁定
                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.解锁
                lock.unlock();
            }
        }
    }
}

synchronized 与 Lock 的比较

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

不同：

synchronized是隐式锁，可以作用在代码块或方法上，机制在执行完相应的同步代码以后，自动的释放同步监视器。
Lock是显式锁，只有代码块，需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）。使用Lock锁，JVM将花费较少的时间来调度线程，性能更高。并且具有更好的扩展性。

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

死锁问题

死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

说明：

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
我们使用同步时，要避免出现死锁。

线程通信

线程的通信涉及到三个方法：

wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify()：一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级更高的那个。
notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程。

说明：
1、三个方法都必须使用在同步代码块或同步方法中。
2、三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则，会出现IllegalMonitorStateException异常
3、三个方法都定义在java.lang.Object类中。

面试题：sleep() 和 wait()的异同？
相同点：
一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
1）两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
2）调用的要求不同：sleep()可以在任何需要的场景下调用， wait()必须使用在同步代码块或同步方法中。
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

生产者消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
分析：

是否是多线程问题？是，生产者线程，消费者线程
是否有共享数据？是，店员（或产品）
如何解决线程的安全问题？同步机制,有三种方法

是否涉及线程的通信？是 ```java public class ProductTest { public static void main(String[] args) {

 Clerk clerk = new Clerk();
 Producer p1 = new Producer(clerk, "生产者-1");
 Consumer c1 = new Consumer(clerk, "消费者-1");
 Consumer c2 = new Consumer(clerk, "消费者-2");
 p1.start();
 c1.start();
 c2.start();

} }

// 店员 class Clerk { private int productNumber = 0;

// 生产产品
public synchronized void produceProduct() {
    if (productNumber < 20) {
        productNumber++;
        System.out.println(Thread.currentThread().getName() + "：开始生产第 " + productNumber + " 个产品");
        notify();
    } else {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
// 消费产品
public synchronized void consumeProduct() {
    if (productNumber > 0) {
        System.out.println(Thread.currentThread().getName() + "开始消费第 " + productNumber + " 个产品");
        productNumber--;
        notify();
    } else {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

}

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

public Producer(){}
public Producer(Clerk clerk, String name) {
    super(name);
    this.clerk = clerk;
}
@Override
public void run() {
    System.out.println(getName() + ": 开始生产产品");
    while (true) {
        try {
            sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        clerk.produceProduct();
    }
}

}

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

public Consumer(){}
public Consumer(Clerk clerk, String name) {
    super(name);
    this.clerk = clerk;
}
@Override
public void run() {
    System.out.println(getName() + ": 开始消费产品");
    while (true) {
        try {
            sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        clerk.consumeProduct();
    }
}

} ```

第7章 多线程

基本概念

程序、进程和线程

Java内存结构图

单核与多核CPU

线程的创建方式

方式1：继承 Thread 类

方式2：实现 Runnable 接口

继承方式与实现方式的比较

方式3：实现 Callable 接口

方式4：使用线程池

线程的生命周期

线程安全

方法1：同步代码块

方法2：同步方法

方法3：lock 锁

synchronized 与 Lock 的比较

死锁问题

线程通信

生产者消费者问题