Gsasuke的博客

原创 自定义类加载器

import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;public class UserCustomerClassLoader extends ClassLoader{ //1、创建一个私有的String类型的classPath变量，确定class文件位置 private String classPath; public UserCusto

原创 refresh( )

refresh()1、准备工作;prepareRefresh();2、创建beanFactoryConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();但是还没有填充属性3、对beanFactory填充属性prepareBeanFactory(beanFactory);4、PostProcessBeanFactory没有具体实现方法，子类覆盖方法做额外的处理，此处我们自己一般不做任何

原创 可重入锁

同步方法public class ReEnterLockDemo { static Object objectLockA = new Object(); public static void m1(){ new Thread(() -> { synchronized (objectLockA){ System.out.println(Thread.currentThread().getName()+"\t"+"

原创 死锁

一、产生死锁代码public class Main{ public static void main(String[] args) { Object o1 = new Object(); Object o2 = new Object(); //t1 和 t2 两个线程共享o1,o2 Thread t1 = new MyThread1(o1,o2); Thread t2 = new MyThread2(o1,o2);

原创 zookeeper

centsos 启动zookeepercd /usr/local/zookeeper/zookeeper-3.4.9/bin./zkServer.sh startmac 启动来到bin文件夹zkServer start

原创 dubbo

打开Dubbo的monitorcd dubbo-admin-distribution/targetjava -jar dubbo-admin-0.3.0-SNAPSHOT.jar

原创 阻塞队列——SynchronousQueue

SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列是阻塞队列的一个实现类，没有容量，与其他的BlockQueue不同，SynchronousQueue是一个不存储元素的BlockQueue，每一个put操作必须等待一个take消费，否则不能消费，也就是说，生产一个消费一个public class HelloGC { public static void main(String[] args) throws InterruptedException { B.

原创 聚簇索引与非聚簇索引

聚簇索引非聚簇索引

原创 链表——两数相加

class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode root= new ListNode(0); ListNode cursor = root; int carry = 0; //只要有一个不为空就继续 while(l1 != null || l2 != null){ //判断..

原创 手写lru算法

public class LRUcache<K,V> extends LinkedHashMap<K,V> { private int size; public LRUcache(int size) { super(size,0.75F,true); this.size = size; } @Override protected boolean removeEldestEntry(Map.Entry<

原创 多个key同时被修改

watch+mutil保证同一个key不被多次修改RedisTemplate template = null;//这里配置自己的redis template.watch("key"); template.multi(); template.opsForValue().set("key","value"); List exec = template.exec(); if (null==exec){ Sy

原创 Jap测试Redis

@SpringBootTestpublic class RedisTest { @Autowired private RedisTemplate<String, String> redisTemplate; @Autowired private HrRepository hrRepository; @Test public void test() throws JsonProcessingException { //1.从

原创 工厂模式

实例化对象，用工厂方法代替new操作，实现了创建者和调用者的分离将选择实现类，创建对象统一管理和控制。从而将调用者与实现类结耦简单工厂模式简单工厂模式也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数的不同来返回不同的对象对于增加新产品无能为力。不修改代码的话是无法拓展的public interface Car { void run();}public class Audi implements Car { @Override public ..

原创 单例模式

单例模式保证一个类只有一个实例，并且提供一个访问该实例的全局访问点例如：数据库连接吃，spring中的每个bean默认是单例的饿汉式线程安全，效率高，但是不能延时加载饿汉式中，static会在类装载时初始化，所以不会涉及多个线程对象访问的问题。但是，如果只是加载本类，而并不调用getInstance()，则会出现资源浪费/** * 饿汉式 */public class SingletonDemo1 { //类初始化时，立刻加载这个对象。加载类时线程安全 （没有延迟加载）

原创 动态规划（2）

动态规划非常多在数组中取一定条件子集的题动态规划最重要的还是要找到状态方程股票买卖问题股票买卖是非常经典的动态规划的题给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。这是股票买卖的动态方程： for(int i=1;i<prices.

原创 回溯算法

原创 N皇后

package Leetcode;public class placeQueens { public static void main(String[] args) { new placeQueens().placeQueens(8); } /* 数组索引是行号，数组元素是列号 */ int[] cols; //多少种方法 int ways; void placeQueens(int n){ i

原创 动态规划

package Leetcode;public class DProgrammer { public static void main(String[] args) { System.out.println(coins(50)); } /* coins(n-25)+1第一次选择25所需要的最少硬币 coins(n-20)+1第一次选择25所需要的最少硬币 coins(n-5)+1第一次选择25所需要的最少硬币 coins(n-1).

原创 算法题1

题目：给定n，构造长度为n的排列，使满足j<j<k的aj，ai，ak，不出现ak+ai=aj*2public class test01 { public static void main(String[] args) { Solve solve = new Solve(); solve.solve(1,10,0); for (int i=1;i<= 10;i++){ System.out.print(solv

原创 ReadWriteLock

读-读能共享读-写不能共享写-写不能共享public class ReadWriteLockDemo { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 1;i<=5;i++){ final int tempInt = i; new Thread(() -> { .

原创 Lock

Lock步骤：1、new ReentrantLock()2、lock.lock() 加锁3、finally代码块中解锁 lock.unlock()import java.util.concurrent.locks.Lock;public class ReentrantLock { public static void main(String[] args) { Ticket2 ticket = new Ticket2(); new Thread((.

原创 自定义线程池

7个线程池参数：corePoolsize：线程池中的常驻核心线程数当线程池中的线程数目达到 corePoolsize 后，就会把任务放到缓存队列中maximumPoolsize：线程池中能够容纳同时执行的最大线程数此值必须大于等于1keepAliveTime：多余的空闲线程的存活时间。当线程池数量超过corePoolsize时，当空闲时间达到keepAliveTime值时，多余空闲线程会被销直到只剩下corePoolsize个线程为止unit：keepAliveTime的单位thread.

原创 线程池执行原理

原创 线程池

1、线程池的使用/** * 第四种使用Java多线程的方式 */public class MyThreadPoolDemo { public static void main(String[] args) { // ExecutorService threadPool = Executors.newFixedThreadPool(5); //一池5个处理线程 // ExecutorService threadPool = Executors.newSingleT

原创 归并排序

import java.util.Arrays;public class TestMain { public static void main(String[] args) { int[] array = {13,56,2,8,19,34,29}; System.out.println(Arrays.toString(array)); mergeSort(array,0,array.length-1); System.out.pr.

原创 ArrayList数组实现方式

如果想在数组的任意位置插入元素，我们需要建立一个新的数组，将插入位置前面的元素拷贝到新数组中，将插入位置后面的元素的下标都后移一位，将插入位置腾出。add方法原码public void add(int index, E element) { /*判断插入的索引是否符合ArrayList范围，在0 和 size之间，size是ArrayList实际元素个数，不包括底层数组的null元素*/ rangeCheckForAdd(index); /*扩容机制：.

转载 常见索引类型

日常开发工作中，涉及到的数据存储，要做查询优化或想深入了解存储引擎，需要对索引知识有个起码的了解，下面介绍下最常见的四种索引结构。位图索引哈希索引BTREE索引倒排索引1、位图索引（BitMap）位图索引适用于字段值为可枚举的有限个数值的情况位图索引使用二进制的数字串（bitMap）标识数据是否存在，1标识当前位置（序号)存在数据，0则表示当前位置没有数据。​图1 为用户表，存储了性别和婚姻状况两个字段。​图2中 分别为性别和婚姻状态建立了两个位图索引；例如：性别->男对

原创 volatile

1、volatile不保证原子性public class VolatileDemo { public static void main(String[] args) { Mydata mydata = new Mydata(); for (int i=1;i<=20;i++){ new Thread(new Runnable() { @Override public voi

原创 数组转化为单向链表再顺序添加

public class SingListNode { //链表类 int val; SingListNode next; public SingListNode(int val) { this.val = val; }}public class SingListNodeInser { SingListNode root ; /* 将数组转化为链表 */ publ

原创 二分法查找

1、循环查找public class BinarySearch { public static void main(String[] args) { int[] arr = {1,2,3,4,5,6,7}; int index = binarySearch(arr,5); System.out.println(index); } public static int binarySearch(int[] arr,int item){.

原创 快速排列

快速排列思想：把数组中最左边数当作基准数，然后从两边进行检索先从右边检索(与基准数反方向)比基准数小的，再从左边检索比基准数大的如果检索到了就停下，然后交换这两个元素，然后继续检索当左边索引与右边索引检索到同一个值时，交换基准数与该位置的值基准数和相遇位置的数交换完成，表示第一轮排序结束，此时基准数左边的值都比他小，右边都比他大以后先排基准数左边，排完后再排右边，方式和第一轮一样import java.util.Random;public class QuickSort { .

原创 UDP协议

接收端使用DatagramSocket指定端口 创建接收端准备容器 封装成DatagramPacket包裹阻塞式接受包裹receive（DatagramPacket p）分析数据 （ byte[] getData() getLength() ）释放资源public class UdpService { public static void main(String[] args) throws IOException { System.out.println(

原创 JVM常用参数

-Xms ：初始大小内存，默认为物理内存的1/64-Xmx : 最大分配内存，默认为物理内存的1/4-Xss ：设置单个线程栈的大小，一般为512k～1024k，等价于-XX:ThreadStackSize-Xmn：设置新生代内存大小-XX:MetaspaceSize：设置元空间大小-XX:PrintGCDetails：输出详细GC收集日志信息-XX:SurvivorRatio：新生代eden和S0/S1空间比例-XX:NewRatio:设置新生代与老年代在堆结构的占比-XX:MaxT..

原创 类的引用

1、类的主动引用（一定会发生类的初始化）new一个类的对象调用静态成员（除了final常量）和静态方法使用jave.lang.reflect包的方法对类进行反射调用当虚拟机启动，java Hello则一定会初始化Hello类，说白了就是先启动main方法所在类当初始化一个类，如果其父类没有被初始化，则优先初始化其父类2、类的被动引用（不会发生类的初始化）当调用一个静态域时，只有真正声明这个域的类才会初始化（通过自类引用父类的静态变量，不会导致子类初始化）public class te

原创 配置JVM 参数

1、Boolean类型公式：-XX:+/- 某个属性值；+表示开启，-表示关闭case：是否打印GC收集细节：-XX:+PrintGCDetails;-XX:-PrintGCDetails是否使用串行垃圾回收器：-XX:+UseSerialGC;-XX:-UseSerialGCpublic class HelloGC { public static void main(String[] args) throws InterruptedException { Syst

原创 集合不安全

Arraylist线程不安全，add方法没有锁会出现ConcurrentModificationException()异常vector线程安全,但是并发性下降Arraylist出现异常public class test07 { public static void main(String[] args) { List<String> list = new ArrayList<>(); for (int i = 1;i<=30.

原创 生产者消费者模式(wait(),notify())

wait()和notify()方法建立在线程安全的基础上两个方法不是thread的方法，是java的方法当调用wait()方法后，当前线程(t线程)立刻进入无限等待状态，并且释放当前线程占有的锁直到调用notify() 方法，才可以让t线程唤醒notify() 方法只会通知，不会释放锁public class ThreadTest11 { public static void main(String[] args) { List list = new ArrayList.

原创 Java锁

1、公平锁和非公平锁公平锁：是指多线程按照申请锁的顺序来获取锁非公平锁：是指多个线获取锁的顺序不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获得锁。在高并发的情况下，有可能造成优先级反转或者饥饿的情况。非公平锁如果占有锁失败，则采用公平锁方式ReentrantLock,Synchroized默认采用非公平锁非公平锁的优点在于吞吐量比公平锁大2、可重入锁（递归锁）指的是同一线程外层函数获得锁，内层递归函数仍能获得锁同一线程外层方法获得锁，进入内层方法自动获得锁线程可以进

原创 自定义Redis序列化

Json序列化@Configurationpublic class RedisConfig { @Bean @SuppressWarnings("all") public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<Str

原创 连接Jedis

1、pom配置<dependencies> <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId>