Java 高级_多线程程序是完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。进程是程序的

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

程序：

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

进程：

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

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

线程：

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

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

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

单核CPU和多核CPU的理解

单核CPU，其实是一种假的多线程，因为在同一时间单元内，只能执行一个线程的任务。
如果是多核的话，才能更好的发挥多线程的效率。
一个Java应用程序 java.exe，其实至少有第三个线程：main()主程序，gc()垃圾回收线程，异常处理线程；当然，如果发生异常，会影响主线程。

并行与并发

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

使用多线程的优点

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

何时需要多线程

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

线程的创建和使用*****

线程的创建：方式一继承 Thread 类

Thread类的有关方法

void start()：启动线程，并执行对象的 run()方法

run()：线程开启后被调用时执行的操作

通常需要重写 Thread类中的此方法，将当前线程需要执行的操作声明在此方法中

String getName()：返回线程的名称

获取当前线程的名字

void setName(String name)：设置该线程名称

设置当前线程的名字

static Thread currentThread()：返回当前线程；在Thread子类中就是 this，通常用于主线程和 Runnable实现类

静态方法，返回执行当前代码的线程

yield()：释放当前 CPU的执行权

释放当前 CPU的执行权，但有可能下一刻又被分配到当前线程

join()

在线程 a中的线程 b.join()调用后，此时线程 a处于阻塞状态，直到线程 b执行完成后，线程 a才结束阻塞状态

stop()：强制结束当前线程的生命周期，不推荐使用(deprecated过时)

sleep(long millitime)：静态方法，使当前线程暂停一段时间 millitime(阻塞)

在指定的时间段内millitime当前线程是阻塞状态

isAlive()：判断当前线程是否还存活

当前线程如果 run()方法执行完成后，就会死亡

线程的优先级等级

MAX_PRIORITY：10 -- 最大
MIN_PRIORITY：1 -- 最小
NORM_PRIORITY：5 -- 默认

获取和设置线程的优先级

getPriority()
setPriority(int p)

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

class HelloThread {
	public void run () {
    	for (int i = 0; i < 100; ++i) {
        	if (i % 2 == 0) {
            	System.out.println(Thread.currentThread().getName() + ':' + i);
            }
            if(0 == i % 20) {
            	yield();
            }
        }
    }
}
public class ThreadMethodTest {
	public static void main (String[] args) {
    	HelloThread h1 = new HelloThread();
        h1.setName("Hello - 1");
        h1.start();
        Thread.currentThread().setName("main - 1");
        
        System.out.println("isAlive: " + h1.isAlive());
        
        for (int i = 0; i < 100; ++i) {
        	if (i % 2 == 0) {
            	System.out.println(Thread.currentThread().getName() + ':' + i);
            }
            if (i == 20) {
            	Thread.currentThread().join();
            }
        }
        // Hello - 1 : ...
        // main - 1 : ...
    }
}

线程的创建和启用

Java语言的JVM允许程序运行多个线程，它通过 java.lang.Thread类来体现
Thread类的特性：
1. 每个线程都是通过某个特定 Thread对象的 run()方法来完成操作的，经常将run()方法的主体称为线程体
2. 通过该Thread对象的 start()方法来启动这个线程，而非直接调用run()

继承于Thread类的方式

创建一个继承于Thread类的子类
重写Thread类的 run()方法 --> 将此线程执行的操作声明在 run()方法中
创建Thread类的子类的对象
通过此对象调用 start()
- 启动当前线程
- 调用 run() 方法

注意点:

不能通过直接调用 run()方法的方式启用线程，只有调用 start()方法才能开启新线程
当需要再次启动一个线程，遍历100以内的数时，不可以让已经 start()的线程去执行；会报错 IllegalThreadStateException，只能再次创建一个线程对象去执行 start()

// 继承于thread类的方式
// 遍历 100 内的所有偶数
class MyThread extends Thread {
	public  void run () {
    	System.out.println("run");
    	for (int i = 0; i <= 100; ++i) {
        	if (i % 2 == 0) {
            	System.out.println("i = " + i);
            }
        }
    }
}
public class ThreadTest {
	public static void main (String[] args) {
    	MyThread mt = new MyThread();
        System.out.println("before");
        mt.start();
        System.out.println("after");
        // before
        // after
        // run
        // i = ...
    }
}

线程的调度

调度策略

时间片：根据时间片占用CPU
抢占式：高优先级的线程抢占CPU

Java的调度方法

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

线程的优先级等级

MAX_PRIORITY：10
MIN_PRIORITY：1
NORM_PRIORITY：5

涉及的方法

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

说明

线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

线程的创建：方式二实现 Runnable 接口

Runnable 接口

创建一个实现了 Runnable接口的类
实现类去实现 Runnable接口的抽象方法 run()
创建此实现类的实例
创建 Thread类的实例，并使用实现类的实例做Thread实例的实参
通过 Thread类的实例去调用 start()方法

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现 Runnable类的抽象方法 run()
 * 3.创建实现类的对象
 * 4.将此对象作为实参传递到 Thread类的构造器中，创建 Thread类的对象
 * 5.通过 Thread类的对象调用 start()方法
 *
 * @author lv
 * @create 2020-11-26 19:08
 */
class RThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (0 == i % 2) {
                System.out.println(Thread.currentThread().getName() + '-' + Thread.currentThread().getPriority() + " : " + i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        RThread r1 = new RThread();
        Thread t1 = new Thread(r1);
        t1.setName("r-t");
        t1.start();
        Thread t2 = new Thread(r1);
        t2.setPriority(Thread.MAX_PRIORITY);
        t2.start();
    }
}

两种创建线程方法的对比：

开发中优先选择：实现 Runnable接口的方式

原因：

实现的方式没有类的单继承性的局限性
实现的方式更适合处理多个线程有共享数据的情况

联系：

public class Thread implements Runnable ,Thread类本身实现了Runnable接口

相同点：

两种方式都需要重写 run()方法，并将要执行的逻辑声明在 run() 方法中

线程的分类

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

形象理解：兔死狗烹，鸟尽弓藏

线程的生命周期 ****

某一个结构从出生到消亡的过程

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

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

线程状态转换

-new-> 新建 -调用start()-> 就绪 -获取CPU执行权/失去CPU执行权、yield()-> 运行 -执行run、调用stop()、Error-> 死亡

-> 运行 -sleep()、join()、等待同步锁、wait()、suspend()-> 阻塞 -sleep时间到、join()结束、获取同步锁、notify()/notify()、resume()-> 就绪 -> ...

线程的同步(安全问题) *****

在Java中，我们通过同步机制，解决线程安全问题

方式一：同步代码块

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

说明：

操作共享数据的代码，即为需要同步的代码
- 不能多包含代码，更不能少包含代码
共享数据：多个线程共同操作的变量
同步监视器：俗称 ‘锁’；任何一个类的对象，都可以充当锁
- 要求：多个线程必须要共用一把锁,唯一的
在使用实现 Runnable接口类创建多线程的方式中，可以考虑使用 this 来充当同步监视器
在使用继承 Thread类创建多线程的方式中，慎用 this充当同步监视器，考虑使用当前类充当同步监视器如：Window.class

class Window implements Runnable {
	private int ticket = 100;
    private Object obj = new Object();
    
    public void run () {
    	synchronized (obj) {
        	while (true) {
            	if (ticket > 0) {
                    System.out.println(ticket);
                    ticket++;
                } else {
                	break;
                }
            }
        }
    }
}
public class WindowTest {
	public static void main (String[] args) {
    	Window w1 = new Window();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w2);
        t1.start();
        t2.start();
    }
}

/**
 *
 * 三个窗口买票，共100张
 * 此方法存在线程的安全问题，待解决
 *
 * 使用同步代码块解决继承 Thread类的方式的线程安全问题
 *
 * @author lv
 * @create 2020-11-25 21:13
 */
class Window2 extends Thread {
    private static int ticket = 100;
    private static final Object OBJ = new Object(); // 同步锁

    public void run() {
        while (true) {

//            synchronized (OBJ) { // 不能使用 this
            synchronized (Window2.class) { // 使用 Window2.class -> 类也是对象

                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        System.out.println("sleep2" + e.getMessage());
                    }
                    System.out.println(getName() + " 卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

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

        t1.setName("window1");
        t2.setName("window2");
        t3.setName("window3");
        t1.start();
        t2.start();
        t3.start();
    }
}

方式二：同步方法

如果操作的共享数据的代码完整的声明在一个方法中，不妨将此方法声明为同步的

同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
非static的同步方法，同步监视器是：this；static的同步方法，同步同步监视器是：当前类本身，如：Window4.class

package com.atguigu.java;

/**
 * 使用同步方法解决实现 Runnable接口的线程安全问题
 *
 *
 * @author lv
 * @create 2020-11-28 16:42
 */
class RThread3 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    public synchronized void show () {
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + ticket);
            ticket--;
        }
    }

}
public class WindowTest3 {
    public static void main(String[] args) {
        RThread3 r = new RThread3();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        Thread t3 = new Thread(r);
        t3.setPriority(6);
        t1.start();
        t2.start();
        t3.start();
    }
}

package com.atguigu.java;

/**
 *
 * 三个窗口买票，共100张
 * 此方法存在线程的安全问题，待解决
 *
 * 使用 同步方法解决继承 Thread类的方式的线程安全问题
 *
 * @author lv
 * @create 2020-11-25 21:13
 */
class Window4 extends Thread {
    private static int ticket = 100;
    private static boolean isLoop = true;
    private static final Object OBJ = new Object(); // 同步锁

    public void run() {
        while (isLoop) {
            show();
        }
    }
    private static synchronized void show () { // static 此时的同步监视器是 Window4.class
//        private synchronized void show () { 此时的同步监视器还是 this不唯一error
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println("sleep2" + e.getMessage());
            }
            System.out.println(Thread.currentThread().getName() + " 卖票，票号为：" + ticket);
            ticket--;
        } else {
            isLoop = false;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();

        t1.setName("window1");
        t2.setName("window2");
        t3.setName("window3");
        t1.start();
        t2.start();
        t3.start();
    }
}

单例模式

package com.atguigu.java1;

/**
 * 使用 同步机制将 单例模式中的懒汉式改写为线程安全的
 *
 * @author lv
 * @create 2020-11-29 13:41
 */
class Bank {
//  声明实例变量
    private static Bank instance = null;
//  1.构造器私有化
    private Bank () {}

//    public static synchronized Bank getInstance () { // 锁是 Bank.class
    public static Bank getInstance () {
//      方式一：效率稍差
//        synchronized (Bank.class) {
//            if (instance == null) {
//                instance = new Bank();
//            }
//            return instance;
//        }
//        方式二：效率更高
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}
public class BankTest {

}

方式三：Lock(锁) - JDK5.0 新增

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

package com.atguigu.java1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三：Lock锁 -- JDK5.0 新增
 * 1.实例化 ReentrantLock
 * 2.调用 lock()方法 - 类似于当前线程获取了同步监视器
 * 3.调用 unlock()方法解锁
 *
 * @author lv
 * @create 2020-11-29 15:42
 */
class Window implements Runnable {
    private int ticket = 100;
    // 1.
    private ReentrantLock lock = new ReentrantLock();

    @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();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized 与 Lock 的异同 *****

优先使用顺序：Lock -> 同步代码块 -> 同步方法

相同：

二者都可以解决线程的安全问题

不同：

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

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

Lock、synchronized两种方式

线程的死锁问题

死锁：

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，程序不会出现异常、不会出现提示，只是所有的线程都处于阻塞状态，无法继续

解决方法：

专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步

线程的通信 ****

对共享数据的操作

package com.atguigu.java2;

/**
 * 线程通信：两个线程交替打印 1-100 的数据
 *
 * 涉及到的三个通信方法
 *
 * wait()：一旦执行此方法，当前线程会进入阻塞状态，并释放同步监视器
 *
 * notify()：一旦执行此方法，就会唤醒被 wait的一个线程，如果有多个线程被 wait，优先唤醒优先级高的线程
 *
 * notifyAll()：一旦执行此方法，就会唤醒所有被 wait的线程
 *
 * 注意点：
 *
 * 1. wait、notify、notifyAll三个方法，必须使用在同步代码块、同步方法中
 * 2. wait、notify、notifyAll三个方法的调用者必须是同步代码块或同步方法中的同步监视器，
 *      否则会报错
 * 3. wait、notify、notifyAll三个方法是定义在 java.lang.Object类中
 *
 * @author lv
 * @create 2020-11-29 17:37
 */
class PrintNum implements Runnable {
//    private int num = 100;
    private int i = 1;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
//            synchronized (this) {
            synchronized (obj) {
//                this.notify();
                obj.notify();
                if (i <= 100) {
                    System.out.println(Thread.currentThread().getName() + " : " + i);
                    ++i;
                    try {
//                        this.wait();
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        PrintNum p = new PrintNum();
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(p);
        t1.setName("t1");
        t2.setName("t2");
        t1.setPriority(7);
        t2.start();
        t1.start();
    }
}

sleep 和 wait 方法的异同 *****

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

不同点：

两个方法声明的位置不同
- Thread类中声明 sleep()
- Object类中声明的 wait()
调用的要求不同
- sleep() 可以在任何需要的场景下调用
- wait() 必须使用在同步代码块、同步方法中
是否会释放同步监视器：sleep()不会释放锁，wait()会释放锁

package com.atguigu.java2;

/**
 * 生产者、销售者、消费者，产品
 *
 * @author lv
 * @create 2020-11-30 19:22
 */

class Clerk {

    private int productCount = 0;
    public synchronized void produceProduct() { // this

        if (productCount < 20) {
            productCount++;
            System.out.println(Thread.currentThread().getName() + " : start produce " + productCount + " product");
            notifyAll();
        } else {
            // wait
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumeProduct() { // this

        if (productCount > 0) {
            System.out.println(Thread.currentThread().getName() + " : start consume " + productCount + " product");
            productCount--;
            notifyAll();
        } else {
            // wait
            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("start produce product");
        while (true) {
//            try {
//                Thread.sleep(20);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            clerk.produceProduct();
        }
    }
}
class Customer extends Thread {

    private Clerk clerk;

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

    @Override
    public void run() {
        System.out.println("start consume product");
        while (true) {
//            try {
//                Thread.sleep(10);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            clerk.consumeProduct();
        }
    }
}

public class ProductTest {
    public static void main(String[] args) {

        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        Producer p2 = new Producer(clerk);
        Customer c1 = new Customer(clerk);
        p1.setName("p1 ");
        p2.setName("p2 ");
        c1.setName("c1 ");
        p1.start();
        p2.start();
        c1.start();
    }
}

JDK5.0 新增线程创建方式 *****

面试：创建多线程有四种方式

方式一：实现 Callable接口

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

call()相比 run() 方法，可以有返回值
call()方法可以抛出异常，被外面捕获，获取异常信息
Callable 支持泛型的返回值
需要借助 FutureTask类，比如获取返回结果

Future接口

可以对具体 Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
FutureTask 是Future接口的唯一实现类
FutureTask 同时实现了 Runnable、Future接口；它既可以作为 Runnable被线程执行，又可以作为 Future得到Callable的返回值

package com.atguigu.java2;

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

/**
 * 创建线程的方式三：实现 Callable接口
 *
 * @author lv
 * @create 2020-12-02 19:04
 */
// 1.创建一个实现 Callable 的实现类
class NumThread implements Callable {
// 2.实现 call() 方法，类似于 run()
    @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;
            }
        }
        // integer
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
//        3.创建 Callable接口实现类的对象
        NumThread n1 = new NumThread();
//        4.将此 Callable接口实现类的对象作为传递到 FutureTask的参数
        FutureTask f1 = new FutureTask(n1);
//        5.将 FutureTask的对象作为参数传递到 Thread类的构造器中，创建 Thread对象，并调用 start()
        new Thread(f1).start();

        try {
//            获取 Callable中 call方法的返回值
            // sum 即为 get()返回值为 FutureTask构造器参数 Callable实现类重写的 call()方法的返回值
            // 可以不调用 get()，放弃返回值
            Object sum = f1.get();
            System.out.println("sumAll: " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式二：使用线程池

线程池相关 API

JDK5.0起提供了线程池相关 API：ExecutorService和 Executors
ExecutorService：真正的线程池接口；常见子类 ThreadPoolExecutor
1. void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行 Runnable
2. Futuresubmit(Callabletask)：执行任务，有返回值，一般又来执行Callable
3. void shutdown()：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
1. Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
2. Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
3. Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
4. Executors.newScheduleThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

背景：

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大

思路：

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中；可以避免频繁创建销毁、实现重复利用；类似于生活中的公共交通工具

好处：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中的线程，避免每次创建）
便于线程管理
1. corePoolSize：核心池的大小
2. maxmumPoolSize：最大线程数
3. keepAliveTime：线程没有任务时最多会保持多长时间后会终止

package com.atguigu.java2;

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

/**
 * @author lv
 * @create 2020-12-02 20:29
 */
class RThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println("i = " + i);
            }
        }
    }
}
class RThread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println("i = " + i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        // 1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        System.out.println(service.getClass());
        ThreadPoolExecutor ser = (ThreadPoolExecutor)service;
        ser.setCorePoolSize(15);
//        ser.setKeepAliveTime();
        // 2.执行指定的线程操作；需要提供实现 Runnable接口或 Callable接口的实现类对象
        service.execute(new RThread1()); // 适合用于 Runnable
        service.execute(new RThread2());
//        service.submit(Callable callable); 适合用于 Callable，获取返回值
        // 3.关闭连接池
        service.shutdown(); // 关闭连接池
    }
}

问题

谈谈你对程序、进程、线程的理解

程序: 为完成特定任务、用某种语言编写的指令的集合；既指一段静态的代码

进程: 程序的一次执行过程，或正在运行的一个程序

线程：进程可以进一步细化为线程，是一个程序内部的一条执行路径

谈谈你对 IDEA 中 Project 和 Module 的理解

Project = E.WorkSpace：是一个项目
Module = E.Project：是一个项目中的模块

线程的通信

以下三个方法，定义在Object类中

wait()
notify()
notifyAll()

同步代码块中涉及到同步监视器和共享数据，谈谈你对同步监视器和共享数据的理解，及注意点

同步监视器

对同一个线程来讲同步监视器必须是唯一的
任何类的对象都可以作为同步监视器
同步监视器可以使用 this、类.class等

共享数据：

多个线程共同操作的数据
利用线程的同步方法来操作共享数据

sleep()和 wait()的区别

sleep

位置不同：sleep声明在 Thread中，wait声明在 Object中
声明位置不同：wait只能用在同步代码、同步方法中，sleep无要求
wait方法会使当前线程放开同步监视器，sleep不会
wait方法需使用 notify或 notifyAll来唤醒线程

单例模式

// 懒汉式
public class Person {
	private static Person instance = null;
	private Person () {}
    public static Person getInstance () {
    	if (instance == null) {
    		synchronized (Person.class) {
        		if (instance == null) {
            		instance = new Person();
            	}	
            }
        }
        return instance
    }
    
}

生命周期

主要关注的是：状态、相应的方法

状态的改变会执行哪些方法(回调方法)
某个方法执行后导致状态的改变
阻塞状态只是一个临时状态，不能是最终状态
死亡：最终状态

创建多线程有哪几种方式：四种

继承 Thread类
实现 Runnable接口
实行 Callable接口
创建线程池
1. 提高响应速度
2. 提高资源重用率
3. 便于管理

synchronized和 Lock方式解决线程安全问题对比

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

不同：

synchronized机制在执行完相应的同步代码后，自动释放同步监视器
lock机制需要手动其它动同步 lock()，同步结束后并手动结束同步 unlock()

Java 高级_多线程

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

线程的创建和使用*****

Thread类的有关方法

void start()：启动线程，并执行对象的 run()方法

run()：线程开启后被调用时执行的操作

String getName()：返回线程的名称

void setName(String name)：设置该线程名称

static Thread currentThread()：返回当前线程；在Thread子类中就是 this，通常用于主线程和 Runnable实现类

yield()：释放当前 CPU的执行权

join()

stop()：强制结束当前线程的生命周期，不推荐使用(deprecated过时)

sleep(long millitime)：静态方法，使当前线程暂停一段时间 millitime(阻塞)

isAlive()：判断当前线程是否还存活

线程的优先级等级

获取和设置线程的优先级

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

线程的创建和启用

继承于Thread类的方式

注意点:

线程的调度

调度策略

Java的调度方法

线程的优先级等级

涉及的方法

说明

Runnable 接口

开发中优先选择：实现 Runnable接口的方式

线程的分类

线程的生命周期 ****

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

线程状态转换

线程的同步(安全问题) *****

在Java中，我们通过同步机制，解决线程安全问题

方式一：同步代码块

方式二：同步方法

单例模式

方式三：Lock(锁) - JDK5.0 新增

synchronized 与 Lock 的异同 *****

优先使用顺序：Lock -> 同步代码块 -> 同步方法

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

线程的死锁问题

死锁：

解决方法：

线程的通信 ****

sleep 和 wait 方法的异同 *****

JDK5.0 新增线程创建方式 *****

面试：创建多线程有 四种方式

方式一：实现 Callable接口

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

Future接口

方式二：使用线程池

线程池相关 API

背景：

思路：

好处：

问题

谈谈你对程序、进程、线程的理解

谈谈你对 IDEA 中 Project 和 Module 的理解

线程的通信

同步代码块中涉及到 同步监视器和 共享数据，谈谈你对同步监视器和共享数据的理解，及注意点

sleep()和 wait()的区别

单例模式

生命周期

创建多线程有哪几种方式：四种

synchronized和 Lock方式解决线程安全问题对比

面试：创建多线程有四种方式

同步代码块中涉及到同步监视器和共享数据，谈谈你对同步监视器和共享数据的理解，及注意点