JUC

1、什么是JUC

---

源码 + 官方文档

业务：普通的线程代码 Thread

Runnable 没有返回值、效率相比入 Callable 相对较低！

2、线程和进程

---

进程：一个程序，QQ.exe Music.exe 程序的集合；

一个进程往往可以包含多个线程，至少包含一个！

Java默认有几个线程？  2 个： mian、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.huang.demo01;
public class Test1 {
    public static void main(String[] args) {
        // 获取cpu的核数
        // CPU 密集型，IO密集型
       System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU的资源
所有的公司都很看重！
企业，挣钱 => 提高效率，裁员，找一个厉害的人顶替三个不怎么样的人；
人员（减少） 、技术成本（提高）

线程有几个状态

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.huang.demo01;
// 基本的卖票例子
import java.time.OffsetDateTime;
/**
* 真正的多线程开发，公司中的开发，降低耦合性
* 线程就是一个单独的资源类，没有任何附属的操作！
* 1、 属性、方法
*/
public class SaleTicketDemo01 {
    public static void main(String[] args) {
      // 并发：多线程操作同一个资源类, 把资源类丢入线程
      Ticket ticket = new Ticket();

      // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式(参数)->{ 代码 }
      new Thread(()->{
          for (int i = 1; i < 40 ; i++) {
          ticket.sale();
          }
      },"A").start();

      new Thread(()->{
          for (int i = 1; i < 40 ; i++) {
          ticket.sale();
          }
      },"B").start();

      new Thread(()->{
          for (int i = 1; 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 接口

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

转载：https://blog.csdn.net/qq_37677354/article/details/105119214