Java进阶-JUC篇

高并发

准备工作：导入maven依赖包

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.8version>
dependency>

第二步，将project里的modules的language level改为jdk8

第三步，将javaCompile改为jdk8

1.什么是JUC

java.util.concurrent 并发

java.util.concurrent.atomic 原子性

java.util.concurrent.locks

业务：普通的线程代码 Thread

Runnable：没有返回值，效率相比于Callable相对较低

2.线程和进程

一个进程可以有多个线程，且至少包含一个。

java默认线程:main ,gc线程，三种开启线程方式：Thread，Runnable，Callable

java是不能真正的开启多线程，源码中是调用了本地native方法，底层C++，java是作用在虚拟机上的，无法直接操作硬件

2.1 并发和并行

并发：多线程操作同一个资源，cpu单核模拟多个线程

并行：多个人一起行走，cpu多核，多个线程可以同时执行，线程池

//获取cpu的核数
//cpu密集型，IO密集型
Runtime.getRuntime().availableProcessors();

并发的本质：充分利用cpu的资源

线程状态：

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

wait/sleep区别：

1.来自不同的类，wait来自obj类，sleep来自Thread类

2.wait会释放锁，sleep不会释放锁

3.使用范围不同：wait必须在同步代码块中，sleep无限制

3.Lock锁

Synchronized同步锁，关键字，本质：排队，锁

并发：多线程操作同一个资源类，把资源类丢进线程里，Runnable函数式接口可以new被成为匿名内部类，但繁琐，所以用lambda表达式来代替()->{}

new Thread(()->{},"name").start;

Interface Lock：

实现类：ReentrantLock可重入锁，ReentrantReadWriteLock.ReadLock读锁，eentrantReadWriteLock.WriteLock写锁

公平锁：十分公平，先来后到

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

Lock：手动加锁，手动释放锁

Synchronized和Lock锁的区别：

1.Synchronized是关键字，Lock是java类

2.Synchronized无法判断获取锁的状态，Lock可以判断是否获取锁

3.Synchronized会自动释放锁，Lock手动释放锁

4.Synchronized线程1获得锁，阻塞；线程2等待，Lock锁会trylock()抓取锁

5.Synchronized可重入锁，非公平锁，不可中断的，Lock锁可重入锁，可以中断，公平锁

6.Synchronized锁少量的代码块，Lock锁大量的代码块

生产者消费者问题

步骤：判断等待，业务，通知

面试：单例模式，排序算法，生产者消费者，死锁

线程也可以唤醒，而不会通知，中断或者超时即所谓的虚假唤醒，等待应该总是出现在while循环中

JUC版的生产者和消费者问题

Lock替代synchronized方法和语句的使用，Condition取代了对象

Condition方法：

condition.await();
condition.signalAll();

package com.liu.demo1;

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

//生产者消费者问题
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();
        /*
        condition.await();
        condition.signalAll();
         */

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

Condition精准通知和唤醒线程

package com.liu.demo1;

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

//生产者消费者问题
public class test {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.printA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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

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

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

}
//等待--业务--通知
class Data{

    private int number = 1;
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    Condition condition4 = lock.newCondition();
        /*
        condition.await();
        condition.signalAll();
         */

    public void printA() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            number=2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printB() throws InterruptedException {
        lock.lock();
        try {
            while (number!=2){
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            number=3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() throws InterruptedException {
        lock.lock();
        try {
            while (number!=3){
                //等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            number=4;
            condition4.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printD() throws InterruptedException {
        lock.lock();
        try {
            while (number!=4){
                //等待
                condition4.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

4.八锁现象

1.执行问题

package com.liu.lock8;

import java.util.concurrent.TimeUnit;
/*
8锁就是8个问题
1.两个线程，总是A先执行，再B执行，是由于锁的原因，synchronized方法锁的对象是方法的调用者，谁先拿到锁谁执行！两个方法用的同一把锁！
2.两个线程，不管方法1睡眠多久，都是方法一先执行，还是方法一先拿到锁！
 */
public class test {
    public static void main(String[] args) throws InterruptedException {
        phone phone = new phone();
        new Thread(()->{
            phone.sendMessage();
        },"A").start();

        //线程睡眠用JUC的TimeUnit枚举类
        TimeUnit.SECONDS.sleep(2);

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class phone{

    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发信息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

package com.liu.lock8;

import java.util.concurrent.TimeUnit;

/*
3.增加一个普通方法后，如果加了锁的方法和普通方法睡眠时间相同，都是锁的方法先执行，如果锁的方法睡眠时间长，就是普通方法先执行！
4.有两个对象，都执行同步方法，睡眠时间短的就先执行！
 */
public class test2 {
    public static void main(String[] args) throws InterruptedException {
        phone phone1 = new phone();
        phone2 phone2 = new phone2();
        new Thread(()->{
            phone1.sendMessage();
        },"A").start();

        //线程睡眠用JUC的TimeUnit枚举类
        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone2.call();
        },"B").start();

    }
}
class phone2{

    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发信息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    //不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

package com.liu.lock8;

import java.util.concurrent.TimeUnit;

/*
5.静态同步方法，只有一个对象，方法一先执行，phone3.class全局唯一对象，static在类加载的时候就执行了，Class模板，锁的是class
6.两个对象，还是静态模块的先后顺序执行，锁的是class！
 */
public class test3 {
    public static void main(String[] args) throws InterruptedException {
        phone3 phone2 = new phone3();
        phone3 phone3 = new phone3();
        new Thread(()->{
            phone2.sendMessage();
        },"A").start();

        //线程睡眠用JUC的TimeUnit枚举类
        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            phone3.call();
        },"B").start();

    }
}
class phone3{

    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发信息");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

package com.liu.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 7.一个静态同步方法，一个普通同步方法，两者锁的对象不同，一个锁的是class模板，一个锁的是方法调用者，谁睡眠时间短谁先执行！
 * 8.两个对象，两个同步方法，还是方法一先执行，锁的对象不同，睡眠时间短的先执行！
 */
public class test4 {
    public static void main(String[] args) throws InterruptedException {
        phone4 phone4 = new phone4();
        phone4 phone5 = new phone4();
        new Thread(()->{
            phone4.sendMessage();
        },"A").start();

        //线程睡眠用JUC的TimeUnit枚举类
        TimeUnit.SECONDS.sleep(3);

        new Thread(()->{
            phone5.call();
        },"B").start();

    }
}
class phone4{

    //锁的class模板
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发信息");
    }
    //锁的是调用者
    public synchronized void call(){
        System.out.println("打电话");
    }
}

5.集合类不安全

并发下的ArrayList不安全，会报错：java.util.ConcurrentModificationException,解决方法：

• 1.Vector objects = new Vector<>();
• 2.Collections.synchronizedList(new ArrayList<>());工具类变成安全的
• 3.JUC下的解决方案: List list1 = new CopyOnWriteArrayList<>();
• 写入时复制，计算机程序设计的一种优化策略，在写入的时候避免覆盖，造成数据问题，读写分离
• 底层就是新复制了一个数组再插入进去，效率高，因为没有用synchronized，用的lock

package com.liu.unsafe;

import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;

public class test {

    public static void main(String[] args) {

        /**并发下的ArrayList不安全，会报错：java.util.ConcurrentModificationException,解决方法：
         * 1.Vector