多线程教程（纯理论 附源码）

多线程

项目链接：项目相关代码

1. 线程简介

run 方法和调用 start 方法开启子线程的区别

• 线程就是独立的执行路径；
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

2. 线程实现得三种方式

Thread(重点)、Runnable（重点）、Callable

继承Thread类

• 启动线程：子类对象 .start()

• 不建议使用：避免OOP单继承的局限性

实现Runnable接口

• 启动线程：传入目标对象+Thread对象.start()

• 推荐使用避免单继承的局限性，方便同一个对象被多个线程使用

3. Lamda表达式

函数时接口：

• 只包含一个抽象方法
• 对于函数式接口可以通过Lamda表达式创建接口对象

new Thread(()->System.out.println("多线程学习...")).start();

4. 线程的常用方法

4.1 线程的五种状态

1. 创建

2. 就绪 在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。

3. 阻塞

   (1)、等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“**等待池”**中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，进入这个状态会释放所占有的所有资源，与阻塞状态不同

   (2)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入**“锁池”**中。这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得

   (3)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。该状态既停止当前线程，但并不释放所占有的资源即调用sleep ()函数后，线程不会释放它的“锁标志”

4. 运行

5. 死亡

setPriority(int newPriority) 线程的优先级在1~10，大的优先

4.1.1线程休眠——sleep()

• sleep（时间）指定当前线程阻塞的毫秒数；

• sleep 时间达到后线程进入就绪状态；

• sleep 每一个对象都有一个锁，sleep 不会释放锁；

4.1.2 线程礼让——yield()

• 将线程从运行状态转为就绪状态；
• 让 CPU 从新调度，有可能还是调度该礼让线程

4.1.3 合并线程——join()

Join合并线程，待该线程执行完成后，再执行其他线程，其他线程阻塞，并不释放所占有的资源

4.2 标志位停止线程

	private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("--- ThreadStop  ---" + i);
            i++;
        }
    }
    public void stop(){
        this.flag = false;
    }

4.3线程优先级

优先级的线程不一定先执行，具体由CPU调度

setPripority 设置线程优先级

Thread.currentThread().getPripority() 获取当前线程的优先级

4.4 守护线程

线程分为用户线程、守护（daemon）线程

虚拟机需等待用户线程执行完毕，不用等待守护线程执行完毕

		Thread thread = new Thread(god);
        thread.setDaemon(true);

4.5 并发

同一个对象被多个线程同时操作

多个线程访问同一个对象，并且某些线程还想修改这个对象.这时候我们就需要线程同步.线程同步其实就是一种等待机制，多个需要同时访问！此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

形成线程安全的两个条件：队列和锁

5.线程同步

为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized

加锁后引起的问题

• 加锁，释放锁会导致比较多的上下文交换和调度延时，引起性能问题

• 加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题

Synchronized(Obj){}

Obj称之为同步监视器

• Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
• 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this,就是这个对象本身，或者是class

6.锁

6.1 同步块

6.2 同步方法

6.3 死锁

死锁产生的四个必要条件

1. 互斥条件：一个资源每次只能被一个进程使用
2. 请求与保持条件：一个进程因为请求资源而阻塞时，对以获得的资源保持不放
3. 不剥夺条件：进程以获得资源，在未使用完之前不能强行剥夺
4. 循环等待条件：若干吸纳成之间形成一种首位相接的循环等待资源关系

6.4 Lock锁

通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

synchronized与Lock的对比

• Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
• Lock只有代码块加锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
• 优先使用顺序：
• Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

sleep和wait的区别

sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行

wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者

1、这两个方法来自不同的类分别是Thread和Object。

​ 2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

7. 线程之间的通信

7.1管程法

• 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；

• 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）

• 缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区

  如果我们要在某个线程中的synchronized块中调用 wait()\notify()\notifyAll() 这几个方法，

  有且只能调用线程所持有的那个锁的对象的wait()\notify()\notifyAll()方法

7.2 信号灯

7.3 线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。

Tips：wait出现的虚假唤醒的情况

出现虚假唤醒的原因是从阻塞态到就绪态再到运行态没有进行判断，我们只需要让其每次得到操作权时都进行判断就可以了；