【JUC并发编程】

什么是JUC

线程是 Java 中浓墨重彩的一笔。

JUC 就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。

这里列举两个之前学习 Java基础 用到过的两个接口：

基础概念

线程和进程

• 进程：一个程序的一次动态执行过程，.exe
• 线程：进程可细分的最小单位，一个进程往往可以包含多个线程

Java 默认有几个线程？

​ 2 个 ！

• main线程

• GC线程

对于Java有哪几种开启线程的方式？

• Thread
• Runnable
• Callable

Java真的可以开启线程嘛？

​ 并不行，需要使用 public native void start0() 方法来调用本地方法使用其他语言开启线程

public synchronized void start() {

    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
        }
    }
}

private native void start0();

并发和并行

• 并发：多个线程操作同一个资源（交替执行）

  本质：充分利用 CPU 的资源

• 并行：多个线程 同时 操作一个资源（同时执行）

  查看 CPU 核心数（CPU核心数代表最多可以并行操作多少线程）

public static void main(String[] args) {
    //获取cpu核心数
    //cpu密集型、io密集型
    System.out.println(Runtime.getRuntime().availableProcessors());		//12
}

线程有几个状态？

​ 六个

public enum State {
    NEW,			//新生
    RUNNABLE,		//运行
    BLOCKED,		//阻塞
    WAITING,		//等待，死死的等
    TIMED_WAITING,	//超时等待
    TERMINATED;		//终止
}

Wait 和 Sleep 的区别：

wait	sleep
Object	Thread
会释放锁	不会释放（睡着了都怎么释放）
必须在同步代码块中使用	可以在任何地方睡
不需要捕获异常	必须捕获异常

Lock锁（重点）

synchronized

public class SaleTicket {

    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        // Runnable @FunctionalInterface 函数式接口，jdk1.8之后可以使用 lambda 表达式
        // ()->{}

        //线程A
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        },"A").start();
		//线程B
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.sale();
            }
        },"B").start();

    }

}

/**
 * 资源类
 * OOP思想
 * 只写属性、方法
 */
class Ticket{
    //属性
    private int number = 30;
    //方法
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "张票，剩余：" + number);
        }
    }
}

加入 synchronized 关键字之前：

加入 synchronized 关键字之后：

Lock接口

• 使用方法

  

• 实现类

• 公平锁和非公平锁

  • 公平锁：十分公平，可以先来后到
  • 非公平锁：十分不公平，可以插队（默认）

• 实例

  class Ticket{
      //属性
      private int number = 30;
  
      Lock lock = new ReentrantLock();
  
      //方法
      public void sale() {
          
  		//加锁
          lock.lock();
  
          try {
              //业务代码
              if (number > 0) {
                  System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "张票，剩余：" + number);
              }
          } catch (Exception e) {
              e.printStackTrace();
          }finally {
              //解锁
              lock.unlock();
          }
      }
  }

  运行结果与使用synchronized 一致

• synchronized 和 Lock锁 的区别

synchronized	Lock
是一个内置的关键字	是一个Java类
无法判断锁的状态	可以判断是否获取到了锁
会自动释放锁	必需要手动释放（不释放会出现死锁）
Thread1(获得锁、阻塞)、Thread2(等待，傻傻的等)	不一定会等下去
可重入锁、不可中断的、非公平的	可重入锁、可以中断的、非公平的（可以设置）
适合锁少量的同步代码	适合锁大量的同步代码

锁是什么？如何判断锁的是谁？

​ 普通方法上锁，锁住的是调用方法的对象实例

​ 静态方法上锁，锁住的是整个类

生产者和消费者问题

问题描述：

本质是线程之间的通信问题

两个线程交替执行，A、B 同时操作同一个变量

A：num + 1

B：num - 1

要保证 num 在 0、1 之间交替

大有门道！

Synchronized版

public class test {

    public static void main(String[] args) {
        Data data = new Data();

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

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

}

/**
 * 是一个资源类
 * 只提供要操作的属性和方法,具有较低耦合性
 * 六字口诀：等待、业务、通知
 */
class Data{

    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        //线程数大于二时，用 if 会出大问题
        while (number != 0) {
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程，+1 完毕
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        //线程数大于二时，用 if 会出大问题
        while (number == 0) {
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程，-1 完毕
        this.notifyAll();

    }
}

问题：

如果存在 A、B、C、D 四个线程，线程还是安全的嘛

答：不安全，存在虚假唤醒问题

解决方法： if —> while

​ 用 if 判断时，当被其他线程唤醒就会直接接着执行后面的指令

​ 用while判断时，当被其他线程唤醒后还会再次进行判断

JUC版

只是对 synchronized版本 的覆盖

public class test {

    public static void main(String[] args) {
        Data data = new Data();

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

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }

}

/**
 * 是一个资源类
 * 只提供要操作的属性和方法,具有较低耦合性
 * 六子口诀：等待、业务、通知
 */
class Data {

    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void increment() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (number != 0) {
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，+1 完毕
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (number == 0) {
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，+1 完毕
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

JUC进阶版

改进：==Condition：精准的通知和唤醒线程==

​ A - B - C 顺序调用

public class Test {

    public static void main(String[] args) {
        Data data = new Data();


        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                data.printA();
            }
        },"A" ).start();
        new Thread(()->{
            for (int i = 0; i < 10 ; i++) {
                data.printB();
            }
        },"B" ).start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C" ).start();

    }

}

class Data{

    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int num = 1;

    public void printA() {
        lock.lock();
        try {
            while (num != 1) {
                condition1.await();
            }
            num = 2;
            System.out.println("AAAAAA");
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB() {
        lock.lock();
        try {
            while (num != 2) {
                condition2.await();
            }
            num = 3;
            System.out.println("BBBBBB");
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC() {
        lock.lock();
        try {
            while (num != 3) {
                condition3.await();
            }
            num = 1;
            System.out.println("CCCCCC");
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

集合类不安全

普通集合类在单线程下安全的不得了，多线程就8行了。

List不安全

public static void main(String[] args) {
    ArrayList<Object> list = new ArrayList<>();

    for (int i = 1; i <= 10; i++) {
        new Thread(() -> {
            list.add(UUID.randomUUID().toString().substring(0, 5));
            System.out.println(list);
        }, String.valueOf(i)).start();
    }
}

存在线程安全问题，爆出错误：java.util.ConcurrentModificationException 并发修改异常

解决方法：

1. List<Object> list = new Vector<>()

2. ``List