【并发编程】

1. 什么是JUC

1.1 JUC简介

在Java中，线程部分是一个重点。JUC就是java.util.concurrent工具包的简称。这是一个处理线程的工具包，JDK1.5开始出现。

1.2 进程与线程

**进程（Process）**是计算机中的程序关于某数集合上的一次运行活动，是系统进行资源分配的调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配的调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。

**线程（thread）**是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

**总的来说： **

• 进程：
  - 指在系统中正在运行的一个应用程序；程序一旦运行就是进程
  - 进程是资源分配的最小单位

• 线程

  • 系统分配处理器时间资源的基本单元，或者说进程之内独立执行一个单元执行流。
  • 线程是程序执行的最小单位

1.3 线程的状态

1.3.1 线程的枚举

• NEW,(新建)
• RUNNABLE,（准备就绪）
• BLOCKED,（阻塞）
• WAITING,（不见不散）
• TIMED_WAITING,（过时不候）
• TERMINATED;(终结)

1.3.2 wait/sleep的区别

• sleep是Thread的静态方法，wait是Object的方法，任何对象实例都能调用
• sleep不会释放锁，他也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁
• 它们都可以被interruptep方法中断

1.4 并行与并发

1.4.1 穿行模式

串行表示所有任务都一一按先后顺序进行。串行意味着必须先做完一件事才能做下一件事。串行是一次只能取得一个任务，并执行这个任务。

1.4.2 并行模式

并行意味着可以同时取得多个任务，并同时去执行所取得的这些任务。并行模式相当于将长长的一条队列，划分成了多条短队列，所以并行缩短了任务队列的长度。并行的效率从代码层次上强依赖于多进程/多线程代码，从硬件角度上则依赖于多核CPU。

1.4.3 并发

**并发（(concurrent)）指的是多个程序可以同时运行的现象，更细化的是多进程可以同时运行或者多指令可以同时运行。**并发是提供一种功能让用户感觉上是多个程序同时运行，但实际上这些程序的进程不是一直霸占cpu的，而是执行一会停一会。

• 并发：同一时刻多个线程在访问同一个资源，多个线程对一个点
• 并行：多项工作一起执行。

1.5 管程

管程(monitor)是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现).但是这样并不能保证进程以设计的顺序执行

JVM 中同步是基于进入和退出管程(monitor)对象实现的，每个对象都会有一个管程(monitor)对象，管程(monitor)会随着 java 对象一同创建和销毁

执行线程首先要持有管程对象，然后才能执行方法，当方法完成之后会释放管程，方法在执行时候会持有管程，其他线程无法再获取同一个管程

1.6 用户线程和守护线程

• 用户线程：平时用到的普通线程，自定义线程
• 守护线程：运行在后台，是一种特殊的线程，比如垃圾回收

当主线程结束后，用户线程还在运行JVM存活，如果没有用户线程，都是守护线程，JVM结束

2 Lock接口

2.1 Synchronized

2.1.1 Synchronized关键字回顾

Synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

• 修饰一个代码块，被修饰的代码块称为同步代码快，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象

• 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象

  • 虽然synchronized可以用来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了该关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此子类的方法也就相当于同步了。

• 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象。

• 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。

2.1.2 售票案例

/**
 * @author pumpkin
 * @date 2021/12/21 0021 下午 23:44
 */

class Ticket{
    //总票数
    private int ticket = 30 ;
    //买票方法
    public synchronized void sale(){
        if( ticket > 0 ){
            System.out.println(Thread.currentThread().getName() + "卖出1张票 剩余" + (--ticket) + "张票" );
        }
    }
}

public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        //创建并启动线程AA
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        },"AA").start();
        //创建并启动线程BB
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        } , "BB").start();
        //创建并启动线程CC
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        } , "CC").start();
    }
}

如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行了该代码块时，其他线程便只能一直等待，等待获取锁的线程，而这里获取锁的线程释放锁只会有两种情况:

• 获取锁的线程执行完了该代码块，然后线程释放对锁的占有
• 线程执行发生了异常，此时JVM会让线程自动释放锁。

那么如果这个获取锁的线程由于等待IO或其他原因（比如调用了sleep方法）被阻塞了，但是有没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
因此就需要一种机制可以不让等待的线程一直无限期等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

2.2 什么是Lock

Lock锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock提供了比synchronized更多的功能。

• Lock与Synchronized的区别
  • Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；
  • Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

下面来逐个讲述Lock接口中每个方法的使用

2.2.2 lock()

lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try语句块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用：

Lock lock = ...
lock.lock();
try{
  //处理任务
}catch(Exception e){

}finally{
	lock.unlock() ; //释放锁
}

2.2.3 newCondition()

关键字synchronized与wait()/notify()这两个方法一起使用可以实现等待//通知模式，Lock锁的newCondition()方法返回Condition对象，Condition类也可以实现等待/通知模式。

用notify()通知时，JVM会随机唤醒某个等待的线程，使用Condition类可以进行选择性通知，Condition比较常用的两个方法：

• await()
  • 使当前线程等待，同时会释放锁，当其他线程调用signal()时，线程会重新获得锁并继续执行。
• signal()
  • 用于唤醒一个等待的线程

注意：在调用Condition的await()/signal()方法前，也需要线程持有相关的Lock锁，调用await()后线程会释放这个锁，在singal()调用后会从当前Condition对象的等待队列中唤醒一个线程，唤醒的线程尝试得到锁，一旦获得锁成功就继续执行。

2.3 ReentrantLock

ReentrantLock，意思是“可重入锁”，ReentrantLock是唯一实现了Locck接口的类，并且ReentrantLock提供了更多的方法。

使用Lock接口实现售票案例

/**
 * @author pumpkin
 * @date 2021/12/25 0025 上午 0:38
 */

class LockTicket{
    private int ticket = 30 ;
    private ReentrantLock lock = new ReentrantLock() ;
    public void sale(){
        //上锁
        lock.lock();
        try {
            if( ticket > 0 ){
                System.out.println(Thread.currentThread().getName() + "卖出1张票 ， 还剩" + (--ticket) + "张票");
            }
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

public class LockSaleTicket {
    public static void main(String[] args) {
        LockTicket lockTicket = new LockTicket();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                lockTicket.sale();
            }
        } , "AA").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                lockTicket.sale();
            }
        } , "BB").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                lockTicket.sale();
            }
        }, "CC").start();
    }
}

2.4 小结

lock和synchronized有以下几点的不同

1. Lock是一个接口，而synchronized是java中的瓜牛腱子，sysnchronized是内置的语言实现。
2. synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象的发生；而Lock在发生异常时，如果没有主动通过unlock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁。
3. Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断。
4. 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5. Lock可以提高多个线程进行读操作的效率。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。

3 线程间通信

线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。

场景：两个线程，一个线程对当前数值加1，另一个线程对当前数值减1，要求用线程间通信

使用synchronized实现

/**
 * @author pumpkin
 * @date 2021/12/25 0025 下午 13:35
 */

/**
 * 用synchronized实现 两个线程交替实现 ， 分别对值num进行加1 减1的操作
 */

class share{
    private int num = 0 ;
    public synchronized void incr() throws InterruptedException {
        if( num != 0 ){
            this.wait(); //wait() 在哪里等待，就在哪里唤醒（存在虚假唤醒问题）
        }
        System.out.println(Thread.currentThread().getName() + "加1完成  num = " + (++num));
        this.notifyAll();
    }

    public synchronized void decr() throws InterruptedException {
        while( num != 1 ){  //wait() 在哪里等待，就在哪里唤醒（存在虚假唤醒问题） 虚假唤醒问题 将代码放在循环中解决(if --> while)
            this.wait();
        }
        System.out.println(Thread.currentThread().getName() + "减1完成 num = " + (--num));
        this.notifyAll();
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        share share = new share();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "BB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "CC").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "DD").start();
    }
}

Lock方案

/**
 * @author pumpkin
 * @date 2021/12/25 0025 下午 14:20
 */

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Lock接口实现 多个线程交替 对num 加1 减1操作
 */

class  Share{
    private int num = 0 ;
    //拿到Lock接口实现类对象
    private Lock lock = new ReentrantLock() ;
    //通过condition对象 实现 等待 通知等功能
    private Condition condition = lock.newCondition() ;

    //+1
    public void incr() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //使用while 避免虚假唤醒
            while( num != 0 ){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName() + "加1完成  num = " + (++num) );
            //通知
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    // -1
    public void decr() throws InterruptedException {
        lock.lock();
        try {
            while( num != 1 ){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName() + "减1完成 num = " + (--num));
            //通知
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "BB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "CC").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "DD").start();
    }
}

3.4 线程间定制化通信

场景： A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照此顺序循环 10 轮

/**
 * @author pumpkin
 * @date 2021/12/25 0025 下午 14:51
 */

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 定制化线程通信
 * A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C
 * 按照此顺序循环 10 轮
 */

class ShareResource{
    private int num = 0 ;
    private int flag = 1 ; // 1 : A  2 : B  3 : C
    private Lock lock = new ReentrantLock() ;
    private Condition Ca = lock.newCondition() ;
    private Condition Cb = lock.newCondition() ;
    private Condition Cc = lock.newCondition() ;

    //打印5次 参数为打印的第loop轮
    public void print5(int loop) throws InterruptedException {
        lock.lock();
        try {
            while( flag != 1 ){
                Ca.await();
            }

            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ":  第" + i + "次" + "  第  " + loop + " 轮");
            }
            flag = 2 ;
            //唤醒
            Cb.signal();
        } finally {
            lock.unlock();
        }
    }

    //打印10次
    public void print10(int loop) throws InterruptedException {
        lock.lock();
        try {
            while( flag != 2 ){
                Cb.await();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":  第" + i + "次" + "  第  " + loop + " 轮");
            }
            flag = 3 ;
            Cc.signal();
        } finally {
            lock.unlock();
        }
    }

    public void print15(int loop) throws InterruptedException {
        lock.lock();
        try {
            while( flag != 3 ){
                Cc.await();
            }
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + ":  第" + i + "次" + "  第  " + loop + " 轮");
            }
            flag = 1 ;
            Ca.signal();
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo3 {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print5(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "AA").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print10(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "BB").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } , "CC").start();
    }
}

synchronized实现同步的基础：Java中的每一个对象都可以作为锁，具体表现为以下3种形式。

• 对于普通同步方法，锁是当前示例对象
• 对于静态同步方法，锁是当前类的class对象
• 对于同步方法块，锁是synchronized括号里配置的对象

4 集合的线程安全

4.1 Vector

ArrayList是线程不安全的，而Vector是线程安全的

Vector是矢量队列，他是JDK1.0版本添加的类。继承于AbstractList，实现了List，RandomAcess，Cloneable这些接口。所以，他是一个队列，支持相关的添加、删除、修改、遍历等功能。