尚硅谷Java第三季--1.javaj基础

最新推荐文章于 2024-03-21 14:13:41 发布
最新推荐文章于 2024-03-21 14:13:41 发布
阅读量441 收藏 3
点赞数
分类专栏： # 尚硅谷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshengwei230612/article/details/109270670
版权

在这里插入图片描述

1. javaj基础

Java字符串常量池

public class StringPools58Demo {
    public static void main(String[] args) {
        /*
        (1).str1
        str1 会有4个对象
           一个StringBuilder、
           一个58 ldc、
           一个tongcheng ldc、
           String
           这个时候常量池中没有58tongcheng这个ldc在
        str1.intern():在jdk7后,会看常量池中是否存在,如果没有,它不会创建一个对象，
                      如果堆中已经这个字符串，那么会将堆中的引用地址赋给它
                      所以这个时候str1.intern()是获取的堆中的
        * */
        String str1=new StringBuilder("58").append("tongcheng").toString();
        System.out.println(str1);
        System.out.println(str1.intern());
        System.out.println(str1==str1.intern());//true
        System.out.println();

        /*
        sum.misc.Version类会在JDK类库的初始化中被加载并初始化,而在初始化时它需要对静态常量字
        段根据指定的常量值(ConstantValue)做默认初始化,此时sum.misc.Version.launcher静态常
        量字段所引用的"java"字符串字面量就被intern到HotSpot VM的字符串常量池 - StringTable
        里了
        str2对象是堆中的
        str.intern()是返回的是JDK出娘胎自带的,在加载sum.misc.version这个类的时候进入常量池
        */
        String str2=new StringBuilder("ja").append("va").toString();
        System.out.println(str2);
        System.out.println(str2.intern());
        System.out.println(str2==str2.intern());//false ，只有jdk自带的字符串如"java"字符串是false,其他字符串都是true

    }
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

利扣算法题：两数之和

在这里插入图片描述

/*
    题目：
    给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那两个整数,
    并返回他们的数组下标你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使
    用两遍。
* */
public class TwoSumDemo {
    public static void main(String[] args) {
        int[]nums ={2, 7, 11, 15};
        int target = 99;
        //int[]indexCollection=twoSum1(nums,target);
        int[]indexCollection=twoSum2(nums,target);
        if(indexCollection!=null){
            for (int index : indexCollection) {
                System.out.print(index+" ");
            }
        }
    }

    //1.暴力法:
    //通过双重遍历数组中所有元素的两两组合,当出现符合的和时返回两个元素的下标
    public static int[] twoSum1(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j <nums.length ; j++) {
                if(target-nums[i]==nums[j]){
                    return new int[]{i,j};
                }
            }
        }
        return null;
    }
    //2.哈希(更优解法)
    public static int[] twoSum2(int[] nums, int target){
        Map<Integer,Integer> map=new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int param=target-nums[i];//2 7
            if(map.containsKey(param)){
                return new int[]{map.get(param),i};
            }
            map.put(nums[i],i);
            //map  k存数组值  v存下标
                    2          0
        }
        return null;
    }
}

java并发编程(juc)

在这里插入图片描述

可重入锁(递归锁)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
隐式(自动挡)是指：jvm自动帮我们加锁释放锁
显示(收动挡)是指：需要自己显示的lock和unLock

在这里插入图片描述

sychronized

隐式锁:(即synchronized关键字使用的锁)默认是可重入锁(同步块、同步方法)
原理如下：

  • 每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针
  • 当执行monitorenter时,如果目标锁对象的计数器为零,那么说明它没有被其他线程持有,Java虚拟机会将该锁对象的持有线程设置为当前线程,并且将其计数器加1,否则需要等待,直至持有线程释放该锁
  • 当执行monitorexit时,Java虚拟机则锁对象的计数器减1。计数器为零代表锁已经被释放

反编译底层原理
在这里插入图片描述

//1.同步代码块

//1.同步代码块
public class SychronizedDemo {
    Object object=new Object();

    public void sychronizedMethod(){
       new Thread(()->{
           synchronized (object){
               System.out.println(Thread.currentThread().getName()+"\t"+"外层....");
               synchronized (object){
                   System.out.println(Thread.currentThread().getName()+"\t"+"中层....");
                   synchronized (object){
                       System.out.println(Thread.currentThread().getName()+"\t"+"内层....");
                   }
               }
           }
       },"A").start();
    }
    public static void main(String[] args) {
        new SychronizedDemo().sychronizedMethod();
        /*
        输出结果：
            A	外层....
            A	中层....
            A	内层....
        * */
    }
}

//2.同步方法

public class ReEnterLockDemo {
    public synchronized void m1() {
        System.out.println("=====外");
        m2();
    }
    public synchronized void m2() {
        System.out.println("=====中");
        m3();
    }
    public synchronized void m3() {
        System.out.println("=====内");
    }

    public static void main(String[] args) {
        new ReEnterLockDemo().m1();
    }

}

输出结果

=====外
=====中
=====内

ReentrantLock

显示锁:(即lock)也有ReentrantLock这样的可重入锁
(注意：有多少个lock,就有多少个unlock,他们是配对使用的；如果多一个或者少一个会使得其他线程处于等待状态)

在这里插入图片描述

class Phone2{
   static ReentrantLock reentrantLock=new ReentrantLock();

    public static void sendSms(){
        reentrantLock.lock();
        /*
        //reentrantLock.lock();
        注意有多少个lock,就有多少个unlock,他们是配对使用的
        如果多了一个lock(),那么会出现线程B一直处于等待状态
        * */
        reentrantLock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t"+"sendSms");
            sendEmails();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }
    }

    private static void sendEmails() {
        reentrantLock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t"+"sendEmails...");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }
    }
}
public class ReentrantLockDemo {
    public static void main(String[] args) {
        Phone2 phone2=new Phone2();
        new Thread(()->{phone2.sendSms();},"A").start();
        new Thread(()->{phone2.sendSms();},"B").start();
    }
}

LockSupport

LockSupport就是对线程唤醒机制(wait/notify)的升级加强版
在这里插入图片描述
在这里插入图片描述
3种让线程等待唤醒的方法：
在这里插入图片描述

synchronized -->wait( )和notify( )

Object类中wait( )和notify( )实现线程的等待唤醒
wait( )：阻塞线程
notify( )：唤醒线程

1. wait和notify方法必须要在synchronized 同步块或同步方法里且成对出现使用。
2. 必须先wait后再notify(如果先notify后wait会出现另一个线程一直处于等待状态)

正常使用
在这里插入图片描述

  • wait和notify方法必须要在synchronized 同步块或同步方法里且成对出现使用。 wait和notify方法两个都去掉同步代码块后看运行效果出现异常情况:
Exception in thread “A” Exception in thread “B”
java.lang.IllegalMonitorStateException

wait和notify方法不能脱离synchronized 同步块或同步方法使用
在这里插入图片描述
不是synchronized 同步块或同步方法使用
在这里插入图片描述
在这里插入图片描述

  • 先notify后wai
    先wait后notify才可以(如果先notify后wait会出现另一个线程一直处于等待状态)

在这里插入图片描述
在这里插入图片描述

ReentrantLock–>await()和signal()

Condition接口中的await和signal方法实现线程等待和唤醒
(出现的问题和object中wait和notify一样)

1. await()和signal()方法必须要在lock和unLock同步块或同步方法里且成对出现使用。
2. 必须先await后再signal(如果先signal后await会出现另一个线程一直处于等待状态)

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

public class LockDemo {
    static Object object=new Object();
    public static void main(String[] args) {
        Lock lock=new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(()->{
            //如果把下行这句代码打开,先signal后await,会出现A线程一直处于等待状态
            //try { TimeUnit.SECONDS.sleep(3);  } catch (InterruptedException e) {e.printStackTrace();}
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"\t"+"coming....");
                condition.await();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
            System.out.println(Thread.currentThread().getName()+"\t"+"END....");
        },"A").start();

        new Thread(()->{
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"\t"+"唤醒A线程****");
                condition.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"B").start();
    }
}
LockSupport–>park()和unpark()
  1. 不用必须写在锁代码块中
  2. 先unpark()，唤醒再park()阻塞，阻塞无效
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

/*
(1).阻塞
 (permit默认是O，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时,
 park方法会被唤醒，然后会将permit再次设置为O并返回)
 static void park()
 static void park(Object blocker)
(2).唤醒
static void unpark(Thread thread)
 (调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，
 permit值还是1)会自动唤醒thread线程，即之前阻塞中的LockSupport.park()方法会立即返回)
 static void unpark(Thread thread)
* */
public class LockSupportDemo {
    public static void main(String[] args) {

        Thread t1=new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t"+"coming....");
            LockSupport.park();
            /*
            如果这里有两个LockSupport.park(),因为permit的值为1,上一行已经使用了permit
            所以下一行被注释的打开会导致程序处于一直等待的状态
            * */
            //LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"\t"+"被B唤醒了");
            },"A");
        t1.start();

        //下面代码一行是为了A线程先执行
       try { TimeUnit.SECONDS.sleep(3);  } catch (InterruptedException e) {e.printStackTrace();}

        Thread t2=new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t"+"唤醒A线程");
            //有两个LockSupport.unpark(t1),由于permit的值最大为1,所以只能给park一个通行证
            LockSupport.unpark(t1);
            //LockSupport.unpark(t1);
        },"B");
        t2.start();
    }
}

在这里插入图片描述

面试题
在这里插入图片描述

AQS

**AQS --> AbstractQueuedSynchronizer (抽象队列同步器): **
用来管理线程的：一个int状态变量+一个队列
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
是一个抽象的类
在这里插入图片描述

和AQS有关的锁
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
锁和AQS同步器的关系
在这里插入图片描述
AQS管理多线程
在这里插入图片描述

A

AQS源码解析

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

AQS内部架构

AQS内部架构图：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

ReentrantLock和AQS的关系

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

ReentrantLock的内部结构

在这里插入图片描述

公平锁和非公平锁

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

多个线程抢锁AQS的执行流程
在这里插入图片描述

在这里插入图片描述
第一个哨兵节点的作用
在这里插入图片描述

在这里插入图片描述

A释放锁 --> B获取锁
在这里插入图片描述

在这里插入图片描述

紫金小飞侠
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
尚硅谷java基础详细笔记（附实例），持续更新中
m0_52181584的博客
07-19 2278
java基础及实例，适合小白初学者
尚硅谷JAVA基础笔记简单整理（一）
qq_45390826的博客
05-11 422
如果一个分支都无法匹配，那么一个分支都不会执行（注意是分支，一个case为一个分支，和分支外需要执行的语句没有关系），如果想要无法匹配也需要执行分支，那么可以增加default关键字（类似于else）。可以使用大小写来实现关键字名称的定义，比如 public 是关键字，不可作为标识符，但是Public 是可以作为标识符的。运算规则：判断条件表达式的结果，如果为true，那么执行任意表达式1的值，如果为false，那么执行任意表达式2的值。这里的类型是元素中类型最大的那一种，最小使用的类型为int类型。
Java学习笔记----第一部分：java基础编程（尚硅谷宋红康老师）
m0_52574098的博客
08-12 4519
了解java的基础知识，学习java中的基本语法，学习java的面向对象和异常知识
尚硅谷JavaSE笔记
qq_44038801的博客
02-29 518
对第一个java程序进行总结java程序编写-编译-运行的过程编写: 编写java文件编译: javac命令编译java文件运行: java命令运行字节码文件在一个java源文件可以声明多个class，但是，只能最多有一个类声明为public。并且要求声明为public的类的类名必须与源文件名相同。程序的入口是main方法，格式是固定的先输出数据，然后换行只输出数据每一行执行语句都以“;”结束。编译的过程：编译以后，会生成一个或多个字节码文件。
尚硅谷全新JavaWeb教程，企业主流javaweb技术栈【学习笔记】一
qq_43668996的博客
03-09 1551
慢慢更新~视频笔记。
Java-JAD.rar_.jad_JavaJ_java jad_java jad_反编译
09-14
Java-JAD.rar_.jad_JavaJ_java jad_java jad_反编译是一个与Java反编译相关的资源，主要用于查看和理解编译后的Java字节码（.class文件）。反编译是将二进制的字节码转换回源代码的过程，这对于软件调试、逆向工程或...
Java面试题-实践.zip
01-01
【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..
全网最齐全的Java面试题库-附答案-持续更新.zip
01-01
【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..
Java interview-高级Java面试题2019.zip
01-01
【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..
Formation-Java:JavaJ2EEHibernateSpring培训
05-16
"Formation-Java: Java J2EE Hibernate Spring培训"涵盖了Java编程基础，以及这些技术在实际项目中的应用。在这个课程中，学员将学习如何使用Java进行基本的编程，理解面向对象的设计原则，以及如何利用J2EE平台构建...
尚硅谷大厂高频面试题第二季
05-29
尚硅谷大厂高频面试题第二季
尚硅谷java全套视频
08-26
尚硅谷java 全套视频 完整无缺，适合java入门提高。
尚硅谷Java核心基础_2019年版
04-08
更适合零基础学员： 自Java语言起源始，循序渐进， 基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 课程中，Eclipse和IDEA这两种企业一线开发环境都使用到了 技术讲解更深入、更全面：
2018尚硅谷最新java和前端视频
12-10
包含2018尚硅谷的Java视频和前端视频，全部是最新的，还有实战课程，面试分享等。
尚硅谷_宋红康_IntelliJIDEA的安装、配置与使用（带目录）
11-19
尚硅谷_宋红康_IntelliJIDEA的安装、配置与使用（带目录） 本课程在腾讯课堂或尚硅谷免费观看学习 尚硅谷 Java视频教程 宋红康 IntelliJIDEA的安装、配置与使用 课程配套文档
尚硅谷全新JavaWeb教程，企业主流javaweb技术栈【学习笔记】二
最新发布
qq_43668996的博客
03-21 1672
1.创建SAXReader对象2.解析XML获取Document对象：需要传入要解析的XML文件的字节输入流3.获取文档的根标签4.获取标签的子标签//获取所有子标签//获取指定标签名的子标签ListsonElementList = rootElement.elements("标签名");
AQS
liuqiang211的专栏
11-24 170
解释：是用来构建锁或者其他同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO(先进先出)队列来完成资源获取线程的排队工作，并通过一个int类变量表示持有锁的状态 CLH是三个科学家的名字首字母 和AQS有关的类 ReentrantLock CountDownLatch ReentrantReadWriteLock Semaphore 锁和AQS的关系：锁面向锁的使用者，定义了程序员和锁交互的使用层API，隐藏了实现细节 同步器AQS是锁的实现 ...
尚硅谷java网络编程
m0_63961750的博客
05-12 147
一、网络编程中有两个主要的问题：1.如何准确地定位网络上一台或多台主机；定位主机上的特定的应用2.找到主机后如何可靠高效地进行数据传输二、网络编程中的两个要素：1.对应问题一：IP和端口号2.对应问题二：提供网络通信协议：TCP/IP参考模型（应用层、传输层、网络层、物理+数据链路层）三、通信要素一：IP和端口号IP:唯一的标识 Internet 上的计算机（通信实体）在Java中使用InetAddress类代表IPIP分类：IPv4 和 IPv6;万维网 和 局域网。
尚硅谷—JAVA学习：2.基本语法（下）运算符、程序流程控制
m0_46475409的博客
07-21 199
0. 目录 1. 运算符 1.1. 算术运算符 1：除法 2：取余 3：自加加，自减减 4. 注意：127的二进制01111111，加一后变为10000000，这是-128的补码 5. 赋值运算符 1.2. 比较运算符 开发中优先使用短路&&，|| 1.3. 位运算符（用的较少） 练习题：交换两个变量的值 1.4. 三元运算符（用的较少） 1.5. 运算符的优先级 2. 程序流程控制 2
银行笔试计算机知识精华：Java基础与系统详解
该资源是一份针对银行笔试的计算机知识复习资料，主要聚焦于Java基础知识以及相关的计算机基础知识。内容涵盖了多项选择题，旨在帮助考生准备银行业务中的技术考核。 1. 题目涉及到了计算机系统的组成，强调硬件...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值