# Java 多线程


<!--more-->

## 基础知识

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

### 进程
是程序的一次执行过程，或是正在运行的一个程序 。是一个动态的过程：有它自身的产生、存在和消亡的过程  
进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域

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

#### 多线程的优点
1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验    
2.提高计算机系统 CPU 的利用率  
3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改  
何时使用:  
* 程序需要同时执行多个任务
* 程序需要实现一些需要等待的任务时
* 需要一些后台运行的程序时

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

### 并行与并发
* 并行: 多个cpu同时执行多个任务.
* 并发: 一个cpu(采用时间切片)同时执行多个任务.比如:秒杀

## 线程创建

### 继承Thread类
Thread构造器  
* Tread() 创建新的Thread对象
* Thread(String threadName) 创建线程并指定线程的实例名
* Thread(Runnable target) 指定创建线程的目标对象，它实现了 Runnable 接口中的 run 方法
* Thread(Runnable target, String name) 创建新的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 异常  
* stop(): 强制线程生命期结束，不推荐使用
* boolean isAlive 返回 boolean ，判断线程是否还活着

```java
class MyTread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}
```

### 实现Runnable接口
```java
class HelloThread implements Runnable{
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
```

> 实现与继承区别
>
> - 继承 Thread ：线程代码存放 Thread 子类 run 方法中。
> - 实现 Runnable ：线程代码存在接口的子类的 run 方法。
>
> 实现方式的好处
>
> - 避免了单继承的局限性
> - 多个线程可以共享同一个接口实现的对象，非常适合多个相同线程来处理同一份资源

### 实现Callable接口

参考juc 中的callable

### 线程池
参考juc 中的线程池

## 线程调度
调度策略  
* 时间片
* 抢占式:高优先级的线程抢占cpu  

Java调度方法
* 同优先级线程组成先进先出队列,使用时间片策略
* 高优先级,使用优先调度的抢占策略  

线程的优先级  
* MAX_PRIORITY 10
* MIN PRIORITY 1
* NORM_PRIORITY 5  

方法 
* getPriority() 返回优先级
* setPriority(int newPriority) 设置优先级  

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

## 线程的分类
Java中的线程分为两类：一种是 **守护线程** ，一种是 **用户线程** 。
* 它们在几乎每个方面都是相同的，唯一的区别是判断 JVM 何时离开。
* 守护线程是用来服务用户线程的，通过在 start() 方法前调用thread.setDaemon (true) 可以把一个用户线程变成一个守护线程。
* Java 垃圾回收就是一个典型的守护线程。
* 若 JVM 中都是守护线程，当前 JVM 将 退出 。

## 生命周期
JDK 中用 Thread State 类定义了线程的几种状态  
要想实现多线程,必须在主线程中创建新的线程对象.Java 语言使用 Thread 类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下的 五种状态


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

![life](https://img.zhaojq.top/20260728130620114.png "life")

## 线程同步

### 同步代码块
```java
    synchronized(同步监视器){
       //需要被同步的代码
    }
```
说明：  
1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。  
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。  
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。  
4.要求：多个线程必须要共用同一把锁。  
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。  

```java
public class SyncTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

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

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

}
//处理实现Runnable接口的纯种安全
class Window1 implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            synchronized (this){
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);

                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
```

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

```java
public class SyncTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

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

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    private synchronized void show(){//同步监视器：this
        //synchronized (this){

        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);

            ticket--;
        }
        //}
    }
}
```

### Lock锁
参考juc 中的Lock锁

### 释放锁操作
* 当前 线程的同步方法、同步代码块 执行结束。
* 当前 线程在同步代码块、同步方法中遇到 break 、 return 终止了该代码块、该方法的继续执行。
* 当前 线程在同步代码块、同步方法中出现了未处理的 Error 或 Exception 导致异常结束。
* 当前 线程在同步代码块、同步方法中执行了线程对象的 wait() 方法，当前线程暂停，并释放锁。

### 线程死锁
* 死锁
    > 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁  
    > 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续  
* 解决方法
    > 专门的算法、原则  
    > 尽量减少同步资源的定义  
    > 尽量避免嵌套同步

```java
public class DeadLockTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

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

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

```java
class Number implements Runnable{
    private int number = 1;
    private Object obj = new Object();
    @Override
    public void run() {

        while(true){

            synchronized (obj) {
                obj.notify();
                if(number <= 100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else{
                    break;
                }
            }

        }

    }
}


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

        t1.setName("线程1");
        t2.setName("线程2");

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

### 生产者消费者案例

```java
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){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            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){
            try {
                Thread.sleep(20);
            } 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);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();

    }
}
```