JUC知识点记录

看完狂神的视频 纯属想记录 回顾 狂神哥直链： 遇见狂神说的个人空间_哔哩哔哩_bilibili 没有不会做的事，只有不想做的事。

进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位
一个进程往往可以包含多个线程，至少包含一个

Java默认有几个线程？2个线程！ main线程、GC线程

线程的状态

public enum State {

    	//运行
        NEW,

    	//运行
        RUNNABLE,

    	//阻塞
        BLOCKED,

    	//等待
        WAITING,

    	//超时等待
        TIMED_WAITING,

    	//终止
        TERMINATED;
    }

线程的生命周期

新建、就绪、运行、阻塞、死亡

JAVA真的可以开启线程吗？ 开不了的！

java是没有权限去开启线程、操作硬件的，这是一个native的一个本地方法，它可以调用底层的c++代码

    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) {
                
            }
        }
    }
	//这是一个C++底层，Java是没有权限操作底层硬件的
    private native void start0();

多线程操作同一个资源

• CPU只有一核，模拟出来多个线程，天下武功唯快不破，那么就会造成一个CPU调度速度很快假象同时执行的，实则是交替执行，并发编程的本质就是充分的利用CPU资源

并行：多个人行走

• CPU多核的情况，多个线程同时执行，我们可以使用线程池！

  获取CPU的核数

  //获取CPU核数
  System.out.println(Runtime.getRuntime().availableProcessors());
  }
  

wait 跟sleep的区别

​ 1、父类不同

​ wait => Object

​ sleep => Thread

一般企业中使用的休眠都是：

package com.neihan.dome;

import java.util.concurrent.TimeUnit;

public class CpuDome {
    public static void main(String[] args) {
        TimeUnit.SECONDS.sleep(1);  // SEConDS 是休眠的单位
    }
}

2、关于锁释放

wait： 会释放锁

sleep：不会释放锁

3、使用的范围是不同的

wait：必须在同步代码块中使用

sleep：可以在任意地方使用

公平锁：十分公平，必须先来后到，先进入的线程先执行

不公平锁：十分不公平，可以插队，当前面的线程需要执行的时间很长的时候，后面的线程可以插队**（默认不公平锁）**

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-umyUkvZy-1636546509443)(C:UsersNeihanAppDataRoamingTyporatypora-user-imagesimage-20211110143059977.png)]

Synchronized与Lock的区别

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

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

3、Synchronized 会自动释放锁，Lock必须手动加锁释放锁

4、Synchronized 线程 A （获得锁->阻塞）线程 B（等待） Lock 就不一定会等下去，Lock有一个trylock去尝试获得锁，不会造成长久的等待。

4、Synchronized 是可重入锁，不可以中断，非公平的，Lock 可重入，可以判断锁，可以自己设置公平锁非公平锁

5、 Synchronized 适合锁少量代码同步问题，Lock适合锁大量的同步代码

synchronized版本

if 判断有虚假唤醒，处理方法用 while

结论：就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。
这也就是为什么用while而不用if的原因了，因为线程被唤醒后，执行开始的地方是wait之后

package com.neihan.pc;
public class ConsumeAndProduct {

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

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

        new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } 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{

    Integer number = 0;
    
    public synchronized void increment() throws InterruptedException {
        //判断等待
       

        while (0!= number){
            this.wait();
        }

        //操作
        number++;
        System.out.println(Thread.currentThread().getName()+"==>"+number);

        //通知
        this.notifyAll();

    }


    public synchronized void decrement() throws InterruptedException {

        //判断
  
        while (0== number){
            this.wait();
        }

        //操作
        number--;
        System.out.println(Thread.currentThread().getName()+"==>"+number);

        //通知
        this.notifyAll();
    }

}

Lock版本

package com.neihan.pc;


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

public class LockCAP {

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

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

        new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } 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{

    Integer number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public  void increment() throws InterruptedException {
        //加锁

        lock.lock();
        try {

            while (0!= number){
                //等待
                condition.await();
            }

            //操作
            number++;
            System.out.println(Thread.currentThread().getName()+"==>"+number);

            //通知
            condition.signalAll();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }


    public  void decrement() throws InterruptedException {

        //加锁
        lock.lock();
        try {

            while (0== number){
                //等待
                condition.await();
            }
            //操作
            number--;
            System.out.println(Thread.currentThread().getName()+"==>"+number);
            //通知
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

指定唤醒线程

精准的通知和唤醒的线程！

如果我们要指定通知的下一个进行顺序怎么办呢？ 我们可以使用Condition来指定通知进程

package com.neihan.pc;

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


public class JUCPC {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{

            for (int i = 0; i < 10; i++) {
                try {
                    data3.printA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        },"A").start();

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

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


class Data3{

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

    Integer number = 1;  // 1A 2B 3C

    public void printA() throws InterruptedException {

        //加锁
        lock.lock();

        try {
            while (number != 1){
                //等待
                condition1.await();
            }

            number = 2;

            System.out.println(Thread.currentThread().getName()+"=>AAAAAAAAA");
            //唤醒 B
            condition2.signal();
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }

    public void printB() throws InterruptedException {

        //加锁
        lock.lock();

        try {
            while (number != 2){
                //等待
                condition2.await();
            }

            number  =3 ;

            //唤醒 C
            System.out.println(Thread.currentThread().getName()+"=>BBBBBBBBBBBB");
            condition3.signal();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }

    public void printC() throws InterruptedException {

        //加锁
        lock.lock();

        try {
            while (number != 3){
                //等待
                condition3.await();
            }
            
            number = 1;
            
            //唤醒 A
            System.out.println(Thread.currentThread().getName()+"=>CCCCCCCCCCCCCC");
            condition1.signal();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

synchronized 锁的是当前的对象

package com.neihan.lock8;

import java.util.concurrent.TimeUnit;


public class Test1 {

    public static void main(String[] args) throws InterruptedException {
        Send send1 = new Send();
        Send send2= new Send();

        new Thread(()->{

            try {
                send1.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"A").start();


        new Thread(()->{
            send2.sendEmail();
        },"B").start();

    }
}


class Send{

    
    public synchronized void sendSms() throws InterruptedException {

        //增加延迟 1 s
        TimeUnit.SECONDS.sleep(1);

        System.out.println("发送短信");

    }

    public synchronized void sendEmail(){
        System.out.println("发送邮箱");
    }
}

static synchronized（静态同步函数）

静态同步函数锁的是类的 Class

package com.neihan.lock8;

import java.util.concurrent.TimeUnit;


public class Test2 {

    public static void main(String[] args) {
        Send2 send = new Send2();

        new Thread(()->{

            try {
                send.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"A").start();


        new Thread(()->{
            send.sendEmail();
        },"B").start();
    }


}


class Send2{

    
    public static synchronized void sendSms() throws InterruptedException {

        //增加延迟 1 s
        TimeUnit.SECONDS.sleep(1);

        System.out.println("发送短信");

    }

    
    public  synchronized void sendEmail(){
        System.out.println("发送邮箱");
    }

}

如果我们使用一个静态同步方法、一个同步方法、一个对象调用顺序是什么？

原因：因为一个锁的是Class类的模板，一个锁的是对象的调用者。所以不存在等待，直接运行。

不安全的 触发 java.util.ConcurrentModificationException 异常 因为底层没有使用 synchronized

解决方案：

1、使用 new Vector<>()
2、Collections.synchronizedList(new ArrayList<>());
3、CopyOnWriteArrayList<>();

CopyonWriteArrayList 比 Vector 好在哪？

Vector 和 CopyonWriteArrayList 的区别
因为 Vector 使用了 synchronized 进行修饰，只要是使用了 synchronized 修饰的效率特别低下。
CopyonWriteArrayList 没有使用 底层是使用的是 Lock锁 写入时复制 效率会更加高效！ COW 计算机程序设计领域的一种优化策略

package com.neihan.unsafe;

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


public class TestList {

    public static  void main(String[] args) {


        List list = new CopyOnWriteArrayList<>();

        

        for (int i = 1; i <=10; i++) {

            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            }).start();
        }
    }
}

默认加载因子是0.75,默认的初始容量是16

new HashMap<>(16,0.75);

package com.neihan.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;


public class TestMap {

    public static void main(String[] args) {

        // 默认等价什么？new HashMap<>(16,0.75);

        //处理方式  Collections.synchronizedMap()
        //处理方式  new ConcurrentHashMap<>();

        Map map = new ConcurrentHashMap<>();

        map.put("A","A");
        map.put("S","B");
        map.put("B","c");
        System.out.println(map);

       

    }
}

HashSet底层是什么？

hashSet底层就是一个HashMap；

public HashSet() {
    map = new HashMap<>();
}

package com.neihan.unsafe;

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


public class TestSet {

    public static void main(String[] args) {

        Set