juc学习_java 判断加锁解锁是同一把锁-CSDN博客

本文链接：https://blog.csdn.net/weixin_44348734/article/details/122825294

课程地址：狂神、尚硅谷

1、什么是JUC

源码+官方文档

JUC是 java util concurrent
面试高频问JUC~！

业务：普通的线程代码 Thread
Runnable 没有返回值、效率相比入 Callable 相对较低！

2、线程和进程

线程、进程，如果不能使用一句话说出来的技术，不扎实！

Java默认有几个线程？ 2 个 mian、GC
提问？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();

// 本地方法，底层的C++ ，Java 无法直接操作硬件 private native void start0();

并发、并行

并发：多线程操作同一个资源。

CPU 只有一核，模拟出来多条线程，天下武功，唯快不破。那么我们就可以使用CPU快速交替，来模拟多线程。

并行：多个人一起行走

CPU多核，多个线程可以同时执行。我们可以使用线程池！

//获取cpu的核数
        System.out.println(Runtime.getRuntime().availableProcessors());

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

线程有几个状态？

线程的状态：6个状态

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
    	//运行
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
    	//运行
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
    	//阻塞
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
    	//等待
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
    	//超时等待
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
    	//终止
        TERMINATED;
    }

wait/sleep的区别

1、来自不同的类

wait => Object

sleep => Thread

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

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

2、关于锁的释放

wait 会释放锁；

sleep睡觉了，不会释放锁；

3、使用的范围是不同的

wait 必须在同步代码块中；

sleep 可以在任何地方睡；

4、是否需要捕获异常

wait是不需要捕获异常；

sleep必须要捕获异常；

3、Lock锁（重点）

传统的Synchronized

16、JMM(java内存模型)

请你谈谈你对 Volatile 的理解

Volatile 是 Java 虚拟机提供轻量级的同步机制
1、保证可见性
2、不保证原子性
3、禁止指令重排

什么是JMM

JMM ： Java内存模型，不存在的东西，概念！约定！

关于JMM的一些同步的约定：
1、线程解锁前，必须把共享变量立刻刷回主存。
2、线程加锁前，必须读取主存中的最新值到工作内存中！
3、加锁和解锁是同一把锁

线程 工作内存、主内存
8种操作：
在这里插入图片描述
内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类
型的变量来说，load、store、read和write操作在某些平台上允许例外）

在这里插入图片描述

public class JmmTest {
    private static int a=1;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while (a==1)//这里a的数据是在工作内存中，所以程序不会停止
            {

            }
        }).start();
        TimeUnit.SECONDS.sleep(6);
        a=0;
        System.out.println(a);
    }
}

17、Volatile

1、保证可见性

public class VolatileTest {
    private volatile static int a=1;//不加volatile程序就会死循环，加了volatile保证程序可见性
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while (a==1)
            {

            }
        }).start();
        TimeUnit.SECONDS.sleep(6);
        a=0;
        System.out.println(a);//打印为0，程序结束
    }
}

2、不保证原子性

原子性 : 不可分割
线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败。

// volatile 不保证原子性
    private volatile static int num = 0;

    public static void add() {
        num++;
    }
    public static void main(String[] args) {
        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){ // main gc
             Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }

如果不加 lock 和 synchronized ，怎么样保证原子性