1、java基础知识图解
2、基本概念：程序、进程、线程
3、线程的创建和使用
4、线程的生命周期
5、线程的同步
6、线程的通信
- 6.1、wait()方法
- 6.2、notify()和notifyAll()
7、JDK5.0 新增线程创建方式
- 7.1、新增方式一：实现Callable接口
- 7.3、线程池相关API

1、java基础知识图解

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

2.1、三者的概念

程序（program）是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象
进程（process）是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

|- 如：运行中的QQ、运行中的网易云音乐
|- 程序是静态的，进程是动态的
|- 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存空间

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

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

单核CPU和多核CPU的理解

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

并行与并发

|- 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事
|- 并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事

2.2、使用多线程的优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何需多线程呢？
多线程程序的优点

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

2.3、何时需要多线程

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

3、线程的创建和使用

3.1、线程的创建和使用

Java语言的JVM运行程序运行多个线程，它通过java.lang.Thread类来实现
Thread类的特性
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称位线程体
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
  3.2、Thread类
构造器
- Thread()：创建新的Thread对象
- Thread(String threadName)：创建线程并指定线程实例名
- Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run()方法
- Thread(Runnable target, String name)：创建新的Thread对象
  3.3、API中创建线程的两种方式——继承Thread
JDK1.5之前创建新执行线程有两种方法：
- 继承Thread类的方式
- 实现Runnable接口的方法
方式一：继承Thread类

1）定义子类继承Thread类
2）子类中重写Thread类中的run()方法。
3）创建Thread子类对象，即创建了线程对象
4）调用线程对象start()方法启动线程，调用run()方法

注意点：
- 如果自己动手调用run()方法，那么就只是普通方法，没有启动多线程模式
- run()方法有JVM调用，什么时候调用，执行的过程都有操作系统的CPU调度决定
- 想要启动多线程，必须调用start()方法
- 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IIIegalThreadStateException”
  3.4、API中创建线程的两种方式——实现Runnable接口
方式二：实现Runnable接口

1）定义子类，实现Runnable接口
2）子类中重写Runnable接口中的run()方法。
3）通过Thread类含参构造器创建线程对象。
4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
5）调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法

3.5、Thread类的有关方法

void start()：启动线程，是线程由新建状态处于就绪状态，获得CPU的资源时，执行对象的run()方法（新建 -> 就绪）
run()：线程在被调度时执行的操作（运行时）
String getName()：返回线程的名称
void setName(String name)：设置线程名称
static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
- Thread.currentThread().getStackTrace()：获取线程栈，完整的调用过程
static void yieId()：线程让步（运行 -> 就绪）
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高级的线程
- 若队列中没有同优先级的线程，忽略此方法
join()：当某个程序执行流中调用其他线程的oin() 方法是，调用线程将被阻塞，直到join() 方法加入的join线程执行完为止（运行 -> 阻塞）
static void sleep(long mills)：（指定时间毫秒）
- 令当前活动线程在指定时间段内放弃对CPU控制，使其它线程有机会被执行，时间到后重排队。
- 抛出InterruptedExcception异常
stop()：强制线程生命期结束，不推荐使用
boolean isAlive()：返回boolean，判断线程是否还活着

3.6、线程的调度
调度策略
- 时间片：
- 抢占式：高优先级的线程抢占CPU
Java的调度方法
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 对高优先级，使用优先调度的抢占式策略
  3.7、线程的优先级
线程的优先级等级
- MAX_PRIORITY：10
- MIN_PRIORITY：1
- NORM_PRIORITY：5
涉及的方法
- getPriority()：返回线程优先值
- setPriority(int newPriority)：改变线程的优先级
说明
- 线程创建时继承父线程的优先级
- 优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用的
  3.8、线程的分类
  Java中的线程分为两类：一种是守护线程，一种是用户线程
它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开
守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程
Java垃圾回收就是一个典型的守护线程
若JVM中都是守护线程，当前JVM将退出
形象理解：兔死狗烹，鸟尽弓藏

4、线程的生命周期
JDK中用Thread.State类定义了线程的几种状态

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

5、线程的同步

5.1、线程同步问题的提出

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

例题

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

    // 1、实现Runnable类，重写run()方法
    class Ticket implements Runnable{
        private int ticket = 50;
        @Override
        public void run() {
            // 5、执行线程的核心操作和功能
            while (ticket > 0){
                if (ticket == 1){
                    try {
                        // 此时库存还剩最后一张票，此处睡眠可以理解为在减库存过程中，有其他操作，导致其他进程认为该票还未卖出，也去销售此票，因此出现超卖的情况
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "窗口售出门票编码" + ticket-- + "。现在剩余门票" + ticket + "张。");
            }
        }
    }
    @Test
    public void saleTicket(){
        // 2、创建实现了Runnable的子类对象
        Ticket ticket = new Ticket();
        // 3、通过Thread类含参构造方法创建线程对象
        Thread window1 = new Thread(ticket,"window1");
        Thread window2 = new Thread(ticket,"window2");
        Thread window3 = new Thread(ticket,"window3");
        // 4、启动线程
        window1.start();
        window2.start();
        window3.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

代码的运行结果如下：

1、通过以上代码发现多线程存在安全问题
2、问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部份，还没有执行完，另一个线程参与进来执行。导致共享数据的错误
3、解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其它线程不可以参与执行

5.2、Synchronized的使用方法

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

1、同步代码块

synchronized(对象){
    // 需要被同步的代码
}

2、synchronized还可以放在方法声明中，表示整个方法为同步方法。

public synchronized void show(String name){
    ……
}

3、针对以上问题加入同步锁

// 1、实现Runnable类，重写run()方法
    class Ticket implements Runnable{
        private Integer ticket = 50;
        @Override
        public void run() {
            // 5、执行线程的核心操作和功能
                while (ticket > 0){
                    synchronized (ticket){
                        if (ticket == 1){
                            try {
                                Thread.sleep(100); // 此时库存还剩最后一张票，此处睡眠可以理解为在减库存过程中，有其他操作，导致其他进程认为该票还未卖出，也去销售此票，因此出现超卖的情况
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                System.out.println(Thread.currentThread().getName() + "窗口售出门票编码" + ticket-- + "。现在剩余门票" + ticket + "张。");
            }
        }
    }
    @Test
    public void saleTicket(){
        // 2、创建实现了Runnable的子类对象
        Ticket ticket = new Ticket();
        // 3、通过Thread类含参构造方法创建线程对象
        Thread window1 = new Thread(ticket,"window1");
        Thread window2 = new Thread(ticket,"window2");
        Thread window3 = new Thread(ticket,"window3");
        // 4、启动线程
        window1.start();
        window2.start();
        window3.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

5.3、同步机制中的锁

同步锁机制：

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

synchronized的锁是什么？
- 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）
- 同步方法的锁，静态方法（类名.class）、非静态方法（this）
- 同步代码块：自己指定，很多时候也是指定为this或类名.class
注意
- 必须确保使用同一个资源的多个线程共有一把锁，这个非常重要，否则无法保证共享资源的安全
- 一个线程类中的所有静态方法共用一把锁（类名.class），所有非静态方法公用一把锁（this），同步代码块（指定需谨慎）
  5.4、同步的范围
如何找问题，即代码是否存在线程安全？（非常重要）

（1）明确哪些代码是多线程运行的代码
（2）明确多个线程是否有共享数据
（3）明确多个线程运行代码中是否有多条语句操作共享数据

如何解决呢？（非常重要）

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其它线程不可以参与执行。即所有操作共享数据的这些语句都要放在同步范围中

切记：
- 范围太小：没有锁住所有的有安全问题的代码
- 范围太大：没发挥多线程的功能
  5.5、释放锁的操作
当前线程的同步方法、同步代码块执行结束。
当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
当前线程在同步代码块、当前方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

5.6、不会释放锁的操作
线程执行同步代码块或同步方法时，程序调用了Thread.sleep()、Thread.sleep()方法暂停当前线程的执行。
线程执行同步代码块时，其它线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
- 应尽量避免使用supend()和resume()来控制线程
  5.7、线程的死锁问题
死锁
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
解决方法
- 专门的算法、原则（银行家算法）
- 尽量减少同步资源的定义
- 尽量避免嵌套同步 ```java class A { public synchronized void foo(B b) { System.out.println(“当前线程名: “ + Thread.currentThread().getName()
```
       + " 进入了A实例的foo方法"); // ①
```
  try {
```
   Thread.sleep(200);
```
  } catch (InterruptedException ex) {
```
   ex.printStackTrace();
```
  } System.out.println(“当前线程名: “ + Thread.currentThread().getName()
```
       + " 企图调用B实例的last方法"); // ③
```
  b.last(); }
  
  public synchronized void last() { System.out.println(“进入了A类的last方法内部”); } }

class B { public synchronized void bar(A a) { System.out.println(“当前线程名: “ + Thread.currentThread().getName()

            + " 进入了B实例的bar方法"); // ②
    try {
        Thread.sleep(200);
    } catch (InterruptedException ex) {
        ex.printStackTrace();
    }
    System.out.println("当前线程名: " + Thread.currentThread().getName()
            + " 企图调用A实例的last方法"); // ④
    a.last();
}
public synchronized void last() {
    System.out.println("进入了B类的last方法内部");
}

}

public class DeadLock implements Runnable { A a = new A(); B b = new B();

public void init() {
    Thread.currentThread().setName("主线程");
    // 调用a对象的foo方法
    a.foo(b);
    System.out.println("进入了主线程之后");
}
public void run() {
    Thread.currentThread().setName("副线程");
    // 调用b对象的bar方法
    b.bar(a);
    System.out.println("进入了副线程之后");
}
public static void main(String[] args) {
    DeadLock dl = new DeadLock();
    new Thread(dl).start();
    dl.init();
}

}

<a name="ljtS6"></a>
## 5.8、Lock
- 从JDK 5.0 开始，Java提供了更强的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁，释放锁。
```java
class A {
    private final ReentrantLock lock = new ReenTrantLock();
    public void m(){
        lock.lock();
        try{
            //保证线程安全的代码; 
        } finally {
            lock.unlock(); 
          } 
        } 
    }
//注意：如果同步代码有异常，要将unlock()写入finally语句块

5.9、synchronized 与 Lock 的对比

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

优先使用顺序：

Lock -> 同步代码块（已经进入了方法体，分配了相应资源）-> 同步方法（在方法体之外）

6、线程的通信

wait() 与 notify() 和 notifyAll()
- wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其它线程调用notify() 或 notifyAll() 方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行
- notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
- notifyAll()：唤醒正在排队等待资源的所有线程结束等待
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IIIlegalMonitorStateException异常。
因为这三个方法有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类声明。

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

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

7、JDK5.0 新增线程创建方式

7.1、新增方式一：实现Callable接口
与使用Runnable相比，Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutrueTask是Future接口的唯一的实现类
- FutrueTask同时实现了Runnable，Future接口。它即可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值 ``` import java.util.concurrent.Callable; import java.util.concurrent.FutureTask;

/**

@Auther: mojh
@Date: 2022/03/30/11:47
@Description: 现在Callable接口和实现Runable接口的区别就是:
Callable带泛型，其call方法有返回值。使用的时候，需要用FutureTask来接收返回值。
而且它也要等到线程执行完调用get方法才会执行，也可以用于闭锁操作。
参考：https://www.jianshu.com/p/1f19835e05c0 */ public class TestCallable {

public static void main(String[] args){ CallableDemo callableDemo = new CallableDemo(); //执行callable方式，需要FutureTask实现类的支持，用来接收运算结果 FutureTask result = new FutureTask<>(callableDemo); new Thread(result).start(); //接收线程运算结果 try { Integer sum = result.get();//当上面的线程执行完后，才会打印结果。跟闭锁一样。所有futureTask也可以用于闭锁 System.out.println(sum); } catch (Exception e) { e.printStackTrace(); } } }

class CallableDemo implements Callable { @Override public Integer call() throws Exception { int sum = 0; for (int i = 0;i<=100;i++){ sum += i; } return sum; } }

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

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

/**

@Auther: mojh
@Date: 2022/03/30/11:28

@Description: 通过创建线程池的方式实现线程创建、执行、关闭。最后记得要关闭线程池 */ public class TestThreadPool {

public static void main(String[] args) throws InterruptedException {

 ThreadPoolDemo tp = new ThreadPoolDemo();
 //1.创建线程池
 ExecutorService pool = Executors.newFixedThreadPool(5);
 CountDownLatch cd = new CountDownLatch(5);
 //2.为线程池中的线程分配任务
 for(int i=0; i<5;i++){
     pool.submit(tp);
     cd.countDown();
 }
 cd.await();
 //3.关闭线程池
 pool.shutdown();

} }

class ThreadPoolDemo implements Runnable { private int i = 0; @Override public void run() { while (i < 100) { System.out.println(Thread.currentThread().getName() + “:” + (i++)); } } } ```

7.3、线程池相关API

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

Java 基础

Java 多线程

1、java基础知识图解

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

2.1、三者的概念

2.2、使用多线程的优点

2.3、何时需要多线程

3、线程的创建和使用

3.1、线程的创建和使用

3.2、Thread类

3.3、API中创建线程的两种方式——继承Thread

3.4、API中创建线程的两种方式——实现Runnable接口

3.5、Thread类的有关方法

3.6、线程的调度

3.7、线程的优先级

3.8、线程的分类

4、线程的生命周期

5、线程的同步

5.1、线程同步问题的提出

5.2、Synchronized的使用方法

5.3、同步机制中的锁

5.4、同步的范围

5.5、释放锁的操作

5.6、不会释放锁的操作

5.7、线程的死锁问题

5.9、synchronized 与 Lock 的对比

6、线程的通信

6.1、wait()方法

6.2、notify()和notifyAll()

7、JDK5.0 新增线程创建方式

7.1、新增方式一：实现Callable接口

7.3、线程池相关API