JUC高并发编程

1 什么是JUC

java.util工具包
业务：普通的线程代码 Thread
Runnable 没有返回值，效率相比于Callable相对较低！

2 线程和进程

线程、进程

进程：

• 一个程序，QQ、music 程序的集合
• 一个进程往往可以包含对个线程，至少包含一个！
• java默认有几个线程？ 2个，main 和 GC

线程

• 开了一个进程Typora，写字，自动保存（线程负责的）
• 对于java而言：Thread、Runnable、Callable

java真的能开启线程吗？ 不能

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

	//本地方法，调运的是底层的c++，java无法直接操作硬件
    private native void start0();

并发、并行

并发（多线程操作同一资源）

• CPU一核，模拟出来多天线程，天下武功，唯快不破，快速交替

并行（多个人一起行走）

• CPU多核，多个线程可以同时执行

package com.swan.demo01;
public class Test1 {
    public static void main(String[] args) {
        // 获取CPU的核数
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质： 充分利用CPU的资源

线程有几个状态（6种）

public enum State {
        // 新生
        NEW,
		//运行
        RUNNABLE,

       	//阻塞
        BLOCKED,

       	//等待
        WAITING,

        //超时等待
        TIMED_WAITING,

        //终止
        TERMINATED;
    }

wait/sleep 区别

1. 来自不同的类
   wait =》Object
   sleep =》Thread
2. 关于锁的释放
   wait 会释放锁，sleep睡觉了，不会释放！
3. 使用的范围是不同的
   wait：必须在同步代码中
   sleep：可以在任何地方睡
4. 是否需要捕获异常
   wait：不需要捕获异常
   sleep：必须要捕获异常

3 lock(锁)

传统 synchronized

package com.swan.demo01;

// 基本的买票例子

/**
 * 真正的多线程
 * 线程就是一个单独的资源类，没有任何附属操作
 *
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类
        Ticket ticket = new Ticket();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}
// 资源类 OOP
class Ticket {
    //属性、方法
    private int number = 30;

    // 买票的方式
    //synchronized 本质：队列，锁
    public synchronized void sale(){
        if (number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number--) + "票,剩余："+number);
        }
    }
}

lock 接口

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

package com.swan.demo01;

// 基本的买票例子

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

/**
 * 真正的多线程
 * 线程就是一个单独的资源类，没有任何附属操作
 *
 */
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类
        Ticket2 ticket = new Ticket2();
        new Thread(() -> { for (int i = 0; i < 40; i++) ticket.sale(); },"A").start();
        new Thread(() -> { for (int i = 0; i < 40; i++) ticket.sale(); },"B").start();
        new Thread(() -> { for (int i = 0; i < 40; i++) ticket.sale(); },"C").start();
    }
}

// 资源类 OOP
//lock锁
// 1 new ReentrantLock();
// 2 加锁
// 3 解锁
class Ticket2 {
    //属性、方法
    private int number = 30;

    Lock lock = new ReentrantLock();
    // 买票的方式
    public synchronized 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 和 Lock 区别

1. synchronized 内置的java关键字，Lock是一个java类
2. synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁
3. synchronized 会自动释放锁，Lock必须要手动释放锁，如果不释放锁，死锁
4. synchronized 线程1（获得锁，阻塞），线程2（等待，傻傻的等）；Lock锁就不一定会等待下去
5. synchronized 可重入锁，不可以中断的，非公平；Lock 可重入锁，可以判断锁，非公平（可以自己设置）
6. synchronized 适合锁少量的代码同步问题，Lock 锁适合锁大量的同步代码

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

4 生产者和消费者问题

生产者和消费者问题 Synchronized 版

package com.swan.pc;


/**
 * 线程之间的通信问题：生产者和消费者问题  等待唤醒  通知唤醒
 * 线程交替执行 A  B 操作同一个变量  num = 0
 * A num + 1
 * B num - 1
 */
public class A {
    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;

    // +1
    public synchronized void increment() throws InterruptedException {
        if (number != 0){ 
            //等待操作
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程 我+1 完毕了
        this.notifyAll();
    }
    // -1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0){
            //等待操作
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程 我-1 完毕了
        this.notifyAll();
    }
}

问题存在 A B C D 4个线！虚假唤醒

if 改为 while 判断

package com.swan.pc;


/**
 * 线程之间的通信问题：生产者和消费者问题  等待唤醒  通知唤醒
 * 线程交替执行 A  B 操作同一个变量  num = 0
 * A num + 1
 * B num - 1
 */
public class A {
    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.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}


//数字 资源类
// 等待 业务 通知
class Data{
    private int number = 0;

    // +1
    public synchronized void increment() throws InterruptedException {
        while (number != 0){
            //等待操作
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程 我+1 完毕了
        this.notifyAll();
    }
    // -1
    public synchronized void decrement() throws InterruptedException {
        while (number == 0){
            //等待操作
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        // 通知其他线程 我-1 完毕了
        this.notifyAll();
    }
}

JUC 版生产者和消费者问题

通过Lock找到Condition

代码实现：当时代码跑起来一直会陷入等待中，没有测试成功

package com.swan.pc;

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

/**
 * 线程之间的通信问题：生产者和消费者问题  等待唤醒  通知唤醒
 * 线程交替执行 A  B 操作同一个变量  num = 0
 * A num + 1
 * B num - 1
 */
public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();
        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 Data2{
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    // +1
    public synchronized 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();
        }
    }
    // -1
    public synchronized 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();
        }
    }
}

Condition 精准的通知和唤醒线程

代码测试

package com.swan.pc;


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

/**
 * 线程之间的通信问题
 * A -> B -> C -> A 按次序执行
 */
public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();
        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 Data3{

    private int number = 1; // 1A 2B 3C

    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    public void printA(){
        lock.lock();
        try {
            while (number != 1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+" =>aaaaaa");
            //唤醒指定的人
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void printB(){
        lock.lock();
        try {
            while (number != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+" =>aaaaaa");
            //唤醒指定的人
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while (number != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+" =>aaaaaa");
            //唤醒指定的人
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

5 8锁现象

如何判断锁的是谁！永远知道什么是锁，锁到底锁的是谁！

深刻理解锁

package com.swan.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是关于锁的8个问题
 * 1、标准情况下，两个线程先打印发短信还是打电话？1/发短信 2/打电话    =》 发短信
 * 2、sendSms延迟4秒，两个线程先打印发短信还是打电话？1/发短信 2/打电话 =》 发短信
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{phone.sendSms();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone.call();},"A").start();
    }
}

class Phone{
    // synchronized 锁的对象是方法的调用者
    //两个方法用的是同一把锁，谁先拿到谁先执行
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}

package com.swan.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是关于锁的8个问题
 * 3、增加了一个普通方法后，先执行发短信还是hello？1/发短信 2/hello =》 hello（普通方法）
 * 4、两个对象，两个同步方法，先执行发短信还是打电话？1/发短信 2/打电话 =》 打电话
 */
public class Test2 {
    public static void main(String[] args) {
        //两个对象，两个不同的调运者，两把锁
        Phone2 phone = new Phone2();
        Phone2 phone2 = new Phone2();
        new Thread(()->{phone.sendSms();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"A").start();
    }
}

class Phone2{
    // synchronized 锁的对象是方法的调用者
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

    //这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

package com.swan.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是关于锁的8个问题
 * 5、增加两个静态的同步方法，只有一个对象，先执行发短信还是打电话？1/发短信 2/打电话 =》 发短信
 * 6、两个对象！增加两个静态的同步方法，只有一个对象，先执行发短信还是打电话？1/发短信 2/打电话 =》 发短信
 */
public class Test3 {
    public static void main(String[] args) {
        //两个对象的class类模板只有一个，static，锁的是class
        Phone3 phone = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{phone.sendSms();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"A").start();
    }
}

class Phone3{
    // synchronized 锁的对象是方法的调用者
    // static 静态方法，类一加载就有了！锁的是class
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }
}

package com.swan.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是关于锁的8个问题
 * 7、1个静态同步方法，一个普通同步方法，只有一个对象，先执行发短信还是打电话？1/发短信 2/打电话 =》 打电话
 * 8、1个静态同步方法，一个普通同步方法，2个对象，先执行发短信还是打电话？1/发短信 2/打电话 =》 打电话
 */
public class Test4 {
    public static void main(String[] args) {
        //
        Phone4 phone = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(()->{phone.sendSms();},"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"A").start();
    }
}

class Phone4{
    // 静态同步方法，锁的是class模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通同步方法，锁的是方法调运者
    public synchronized void call(){
        System.out.println("打电话");
    }
}

小结

new： this 具体的一个手机

static： class 唯一的一个模板

6 集合类不安全

6.1 List不安全

package com.swan.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

// java.util.ConcurrentModificationException  并发修改异常
public class ListTest {
    public static void main(String[] args) {
        // 并发下 ArrayList 是不安全的
        /**
         * 解决方案:
         * 1、List list = new Vector<>();
         * 2、List list = Collections.synchronizedList(new ArrayList<>());
         * 3、List list = new CopyOnWriteArrayList<>();
         */
        //CopyOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略；
        // 多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）
        //在写入的时候避免覆盖，造成数据问题
        // CopyOnWriteArrayList 比 Vector 好在哪里？读写分离
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

6.2 Set不安全

package com.swan.unsafe;


import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * java.util.ConcurrentModificationException 并发修改异常
 */
public class SetTest {
    public static void main(String[] args) {

        // 并发下 HashSet 是不安全的
        /**
         * 解决方案:
         * 1、Set