JUC底层的详细学习(狂神JUC笔记)(全网最全)---什么是JUC

JUC底层的详细学习(狂神JUC笔记)(全网最全)---什么是JUC 什么是JUC

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

线程和进程

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

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

Java是没有权限去开启线程、 *** 作硬件的，这是一个native的一个本地方法，它调用的底层的C++代码。

线程有几个状态？
线程的状态：6个状态

public enum State {
        
    	//运行
        NEW,

        
    	//运行
        RUNNABLE,

        
    	//阻塞
        BLOCKED,

        
    	//等待
        WAITING,

        
    	//超时等待
        TIMED_WAITING,

        
    	//终止
        TERMINATED;
    }

1、来自不同的类

wait => Object

sleep => Thread

一般情况企业中使用休眠是：

TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s

2、关于锁的释放

wait 会释放锁；

sleep睡觉了，不会释放锁；

3、使用的范围是不同的

wait 必须在同步代码块中；

sleep 可以在任何地方睡；

4、是否需要捕获异常

wait是不需要捕获异常；

sleep必须要捕获异常；

Lock锁（重点）

1.传统的Synchronized

package com.whf.juc;


//基本的卖票例子


public class SaleTicketDemo01 {

    public static void main(String[] args) {
        //多线程 *** 作 同一个资源类 把资源类丢入线程
        Ticket ticket = new Ticket();

        new Thread(()->{
            for (int i = 1 ; i < 60; i++) {
                ticket.sale();
            }

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


    }
}
//synchronized 相当于全自动
//资源类 OOP
class Ticket {

    private int number = 50;

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

Lock lock = new ReentrantLock();

    
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

2.synchronized本质队列锁

公平锁： 十分公平，必须先来后到~；

非公平锁： 十分不公平，可以插队；(默认为非公平锁)

package com.whf.juc;

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



public class SaleTicketDemo02 {

    public static void main(String[] args) {
        //多线程 *** 作 同一个资源类 把资源类丢入线程
        Ticket2 ticket2 = new Ticket2();

        new Thread(()->{
            for (int i = 1 ; i < 60; i++) {
                ticket2.sale();
            }

        }, "A").start();
        new Thread(()->{
            for (int i = 1 ; i < 60; i++) {
                ticket2.sale();
            }
        }, "B").start();
        new Thread(()->{
            for (int i = 1 ; i < 60; i++) {
                ticket2.sale();
            }
        }, "C").start();


    }
}

//资源类 OOP 相当于手动


class Ticket2 {

    private int number = 50;
    //可重入锁 加上true就变成公平锁了
    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 和 Lock区别

1、Synchronized 内置的Java关键字，Lock是一个Java类2、Synchronized 无法判断获取锁的状态，Lock可以判断3、Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！可能会遇到死锁4、Synchronized 线程1(获得锁->阻塞)、线程2(等待)；lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。5、Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；

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