Java基础-2、并发

class TestSynchronized{
    Object lock = null;
    public void method1(){
        lock = new Object();
        synchronized (lock){
            System.out.println("----method1----");
        }
    }
    public void method2(){
        synchronized (this){
            System.out.println("----method2----");
        }
    }
    public synchronized void method3(){
        System.out.println("----method3----");
    }
    public static synchronized void method4(){
        System.out.println("----method4----");
    }

}

类别	Synchronized	Lock
存在形式	JAVA关键字，JVM	是一个类
锁的释放	获取锁的线程执行完成同步中的代码线程发生异常	在finally中必须释放锁，不然会造成死锁
获取锁	如果A线程获取了锁，那么B线程等待。如果A线程阻塞，那么B线程会一直等待	Lock有多种锁的获取方式，都可以尝试获得锁，线程可以不用一直等待
锁状态	无法判断	可判断
锁类型	悲观锁（可重入不可中断非公平）	乐观锁（可重入可判断可公平（两者皆可））
性能	少量同步	大量同步
	偏向锁-》轻量级锁-》重量级锁（1.6后）	互斥锁ReentrantLock

Volatile

volatile：用来修饰被不同线程访问和修改的变量

volatile关键字与JVM内存模型相关

Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了同步块和volatile关键字机制

volatile关键字机制：

synchronized修饰方法和代码块，以实现同步

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的值。volatile经常被误用进行原子性的操作。但是这些操作并不是真正的原子性。在读取加载之后，如果变量发生了变化，线程工作内存中的值由于已加载，不会产生对应的变法。对于volatile修改的变量，JVM只是保证从内存加载到线程工作内存的值是最新的。

交互图：

public class VolatileTest {
   //public static int count = 0; //实际运算每次结果都不一样
   public static volatile int count = 0; //
   public static void inc(){
       //这里延迟1毫秒，使得结果明显
       try {
           Thread.sleep(1);
       } catch (Exception e) {
           // TODO: handle exception
       }
       count ++;
   }

   public static void main(String[] args) {
       //同时启动1000个线程，去进行i++运算，看看实际结果
       for (int i = 0; i < 1000; i++) {
           new Thread(new Runnable() {
               @Override
               public void run() {
                   VolatileTest.inc();
               }
           }).start();
       }

       System.out.println("运行结果:"+count);
   }

}

信号量Semaphore

在多线程中，线程间传递信号的一种方式。

与互斥量的区别

互斥量用于线程的互斥，信号量用于线程的同步
互斥量值只能为0/1，信号量值可以为非负整数。信号量可以实现多个同类资源的多线程互斥和同步。
互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。

class TestSemaphore{
    Semaphore semaphore = new Semaphore(10);//控制10个共享资源的使用
    public void use(){
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void release(){
        semaphore.release();
    }
}

实现所有线程在等待某个事件的发生才去执行

1.闭锁CountDownLatch

闭锁是典型的等待事件发生的同步工具类，将闭锁的初始值设置1，所有线程调用await方法等待，当事件发生时调用countDown将闭锁值减为0，则所有await等待闭锁的线程得以继续执行。

class TestCountDownLatch{
    public static void main(String[] args){
        int num = 2;
        final CountDownLatch latch = new CountDownLatch(num);
        for(;num> 0;num--){
            new Thread(){
                public void run() {
                    try {
                        System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                        Thread.sleep(3000);
                        System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                        latch.countDown();
                    } catch (InterruptedException e) {
                       e.printStackTrace();
                    }
                };
            }.start();
        }
        try {
            System.out.println("等待2个子线程执行完毕...");
            latch.await();
            System.out.println("2个子线程已经执行完毕");
            System.out.println("继续执行主线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.阻塞队列BlockingQueue

所有等待事件的线程尝试从空的阻塞队列获取元素，将阻塞，当事件发生时，向阻塞队列中同时放入N个元素(N的值与等待的线程数相同)，则所有等待的线程从阻塞队列中取出元素后得以继续执行。

3.信号量Semaphore

设置信号量的初始值为等待的线程数N，一开始将信号量申请完，让剩余的信号量为0，待事件发生时，同时释放N个占用的信号量，则等待信号量的所有线程将获取信号量得以继续执行。

class TestSemaphore{
    public static void main(String[] args){
        // 8位工人
        int n = 8;
        // 5台机器
        Semaphore semaphore = new Semaphore(5);
        for(int i=0;i<n;i++){
            new Worker(i,semaphore).start();
        }
    }
    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
          this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4.栅栏CyclicBarrier

设置栅栏的初始值为1，当事件发生时，调用barrier.wait()冲破设置的栅栏，将调用指定的Runable线程执行，在该线程中启动N个新的子线程执行。这个方法并不是让执行中的线程全部等待在某个点，待某一事件发生后继续执行。

class TestCyclicBarrier{
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier = new CyclicBarrier(N);
        for(int i=0;i<N;i++){
            new Writer(barrier).start();
        }
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                //以睡眠来模拟写入数据操作
                Thread.sleep(5000);
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }

            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }
    }
}

CAS缺陷以及如何解决

参考地址：https://blog.csdn.net/jeffleo/article/details/75269618

CAS：Compare And Swap，即比较并交换。（AtomicInteger）

实现了Java多线程的并发操作。整个AQS同步组件、Atomic原子类操作等都是以CAS实现的，甚至ConcurrentHashMap在1.8的版本中也调整为了CAS+Synchronized。可以说CAS是整个JUC的基石。

缺陷：

主要表现在三个方法：

循环时间太长

只能保证一个共享变量原子操作

ABA问题：解决方案则是版本号

AQS

参考资料：https://www.cnblogs.com/daydaynobug/p/6752837.html

AQS:AbstractQueuedSynchronized, 抽象的队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock/Semaphore/CountDownLatch

AQS里的state只有两种状态：0表示未锁定，1表示锁定

死锁、活锁

死锁：指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。4个产生条件：

互斥条件
请求和保持条件
不剥夺条件
环路等待条件

活锁：指的是任务或者执行者没有被阻塞，由于某些条件没有满足，导致一直重复尝试—失败—尝试—失败的过程。处于活锁的实体是在不断的改变状态，活锁有可能自行解开。

线程池

资源地址：https://blog.csdn.net/wxq544483342/article/details/53118674

线程池的种类

1、创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE

         ExecutorService pool = Executors.newCachedThreadPool();

2、创建容量为1的缓冲池

        ExecutorService pool = Executors.newSingleThreadExecutor();

3、创建固定容量大小的缓冲池

ExecutorService pool = Executors.newFixedThreadPool(int);

4、创建一个定长线程池，支持定时及周期性任务执行。

         ExecutorService pool = Executors.newScheduledThreadPool(1);

5、创建一个拥有多个任务队列（以便减少连接数）的线程池。

         ExecutorService pool = Executors.newWorkStealingPool();

ExecutorService类的方法：

void shutdown();

         关闭线程池 不可以再 submit 新的 task，已经 submit 的将继续执行

         List<Runnable> shutdownNow();

         关闭线程池 试图停止当前正在执行的 task，并返回尚未执行的 task 的 list

         boolean isShutdown();

         是否已经关闭了线程池，当调用shutdown()或shutdownNow()方法后返回为true。

         boolean isTerminated();

         当调用shutdown()方法后，并且所有提交的任务完成后返回为true;

          当调用shutdownNow()方法后，成功停止后返回为true;

         boolean awaitTermination(long timeout, TimeUnit unit) throws         InterruptedException;

         <T> Future<T> submit(Callable<T> task);

         <T> Future<T> submit(Runnable task, T result);

         Future<?> submit(Runnable task);

         <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)

         throws InterruptedException;

         <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,

                              long timeout, TimeUnit unit)

         throws InterruptedException;

         <T> T invokeAny(Collection<? extends Callable<T>> tasks)

         throws InterruptedException, ExecutionException;

         <T> T invokeAny(Collection<? extends Callable<T>> tasks,

                long timeout, TimeUnit unit)

         throws InterruptedException, ExecutionException, TimeoutException;

配置线程池大小

CPU密集型任务，就需要尽量压榨CPU，参考值可以设为 NCPU+1
IO密集型任务，参考值可以设置为2*NCPU

工作机制及原理

线程池的两个核心队列：

线程等待池，即线程队列BlockingQueue
任务处理池(PoolWorker)，即正在工作的Thread列表(HashSet)

线程池的核心参数：

核心池大小（corePoolSize）,即固定大小，设定好之后，线程池的稳定峰值，达到这个值之后池的线程数大小不会释放。
最大处理线程池数（maximumPoolSize）,当线程池里面的线程数超过corePoolSize，小于maximumPoolSize时会动态创建与回收线池里面的线程池资源。

ThreadPoolExecutor类

构造方法：

/**

 *

 * @param corePoolSize  核心池大小 默认情况下，在创建好线程池之后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，

 *                      当线程池中的线程数量达到corePoolSize后，就会把这些任务放到缓存队列中

 * @param maximumPoolSize 线程池最大线程数量，表示在线程池中最多能创建线程的数量；在corePoolSize和maximumPoolSize的线程数会被自动释放，而小于corePoolSize的则不会。

 * @param keepAliveTime 表示线程没有执行任务时最多保持多久时间会终止。

 *                      默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会生效,直到线程池数量不大于corePoolSize，

 *                      即只有当线程池数量大于corePoolSize数量，超出这个数量的线程一旦到达keepAliveTime就会终止。

 *                      但是如果调用了allowCoreThreadTimeout(boolean)方法，即使线程池的线程数量不大于corePoolSize，线程也会在keepAliveTime之后就终止，知道线程池的数量为0为止。

 * @param unit 参数keepAliveTime的时间单位，一个时间单位枚举类。 Nanos/Micros/Millis/Seconds/Minutes/Hours/Days

 * @param workQueue 一个阻塞队列，用来存储等待执行任务的队列，这个参数选择也很重要，会对线程池的运行过程产生重大影响。

 *                  一般来说，这里的阻塞队列就是（ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue）。

 * @param threadFactory 线程工厂，主要用来创建线程；可以是一个自定义的线程工厂，默认就是Executors.defaultThreadFactory()。用来在线程池中创建线程。

 * @param handler 表示当拒绝处理任务时的策略，也是可以自定义的，默认是我们前面的4种取值：

 *                  ThreadPoolExecutor.AbortPolicy（默认的，一言不合即抛异常的）

 *                  ThreadPoolExecutor.DiscardPolicy（一言不合就丢弃任务）

 *                  ThreadPoolExecutor.DiscardOldestPolicy（一言不合就把最近的任务给抛弃，然后执行当前任务）

 *                  ThreadPoolExecutor.CallerRunsPolicy（由调用者所在线程来执行任务）

 */

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,

BlockingQueue<Runnable> workQueue, public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,

BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,RejectedExecutionHandler handler) {

if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0)

throw new IllegalArgumentException();

if (workQueue == null || threadFactory == null || handler == null)

throw new NullPointerException();

this.corePoolSize = corePoolSize;

this.maximumPoolSize = maximumPoolSize;

this.workQueue = workQueue;

this.keepAliveTime = unit.toNanos(keepAliveTime);

this.threadFactory = threadFactory;

this.handler = handler;

}

ThreadLoad原理

class TestThreadLocal{
    private static TestThreadLocal testThreadLocal = null;
    private static ThreadLocal<TestThreadLocal> map = new ThreadLocal<TestThreadLocal>();
    private TestThreadLocal(){}
    public static synchronized TestThreadLocal getInstance1(){
        if(testThreadLocal==null){
            testThreadLocal = new TestThreadLocal();
        }
        return testThreadLocal;
    }
    public static TestThreadLocal getInstance2(){ //效率大于getInstance1()
        testThreadLocal = map.get();
        if(testThreadLocal==null){
            testThreadLocal = new TestThreadLocal();
            map.set(testThreadLocal);
        }
        return testThreadLocal;
    }
}

LockSupport工具

LockSupport提供了park和unpark方法实现阻塞和解除阻塞，都是基于“许可（permit）”作为关联。permit相当于一个信号量(0,1),默认是0。

使用偏移量来获取对象。是因为线程已经被阻塞了，如果不通过内存的方式，直接调用线程内的方法，线程是不会响应的。

park()、unpark()和wait()、notify()的区别

面向的主体不同。LockSupport是针对Thread进行阻塞，可以指定阻塞的对象，每次可以唤醒指定具体的线程。Wait()是以对象，阻塞当前的线程和唤醒单个线程或者所有线程。
实现的机制不同。LockSupport可以指定monitor的object对象，但和object.wait()两者的阻塞队列并不交叉。

static void testLockSupport(){
    // 调用native方法阻塞当前线程
    LockSupport.park();
    // 阻塞当前线程，最长不超过nanos纳秒，返回条件在park()的基础上增加了超时返回
    LockSupport.parkNanos(1);
    // 阻塞当前线程，知道deadline时间（deadline - 毫秒数）
    LockSupport.parkUntil(1);

    Object blocker = new Object();
    //1) 记录当前线程等待的对象（阻塞对象）；
    //2) 阻塞当前线程；
    //3) 当前线程等待对象置为null。
    LockSupport.park(blocker);
    // 阻塞当前线程，最长等待时间不超过nanos毫秒，同样，在阻塞当前线程的时候做了记录当前线程等待的对象操作
    LockSupport.parkNanos(blocker,1);
    // 阻塞当前线程直到deadline时间，相同的，也做了阻塞前记录当前线程等待对象的操作
    LockSupport.parkUntil(blocker,1);

    // 唤醒处于阻塞状态的线程Thread
    LockSupport.unpark(new Thread());
}

Condition原理

在经典的生产者和消费者模式中，可以使用Object.wait()和Object. Notify()阻塞和唤醒线程，但这样处理只有一个等待队列。在可重入锁ReentrantLock中，使用AQS的condition可以实现设置多个等待队列，可以使用lock.newCondition生成一个等待队列。

static void testCondition() throws InterruptedException {
    // 需要结合lock使用
    Lock lock = new ReentrantLock();
    final Condition notEmpty = lock.newCondition();

    // 将当前线程阻塞，调用await()之前必须先获取锁，
    // 调用await()时，将线程构造成节点加入等待队列，同时释放锁，并挂起当前线程
    notEmpty.await();
    notEmpty.await(1, TimeUnit.MINUTES);
    notEmpty.awaitNanos(1);
    notEmpty.awaitUninterruptibly();
    notEmpty.awaitUntil(new Date());

    // 另一个线程将已经阻塞的线程唤醒
    // 其他线程调用signal()时也必须获取锁，
   // 当执行signal()方法时将等待队列的节点移入到同步队列，
    // 当线程退出临界区释放锁时，唤醒同步队列的首个节点
    notEmpty.signal();
    notEmpty.signalAll();
}

Fork/Join框架的理解

并行流：把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。（fork/join框架）

串行流：则相反

Fork/Join框架：

在必要的情况下，将一个大的任务进行拆分(fork)成若干个子任务（拆到临界值），再将一个个任务的结果进行join汇总。

Fork/Join与线程池的区别：

Fork/Join采用“工作窃取模式”，当执行新的任务时可以将其拆分成更小的任务执行，并将小任务加到线程队列中。然后再随机从一个线程中偷一个任务并把他加入到自己的队列中。

例如：CPU上有两个线程A/B，A已经执行完了，B还有任务未执行。这时A将B队尾的任务偷过来，加入到自己的队列中。相对于传统的线程池，Fork/Join更有效的使用了CPU资源。

// ForkJoin这个框架的实现需要继承RecursiveTask 或者 RecursiveAction，
// RecursiveTask是有返回值的，相反RecursiveAction则没有
@Data
public class TestForkJoinWork extends RecursiveTask<Long> {
    private Long start;
    private Long end;
    public static final Long CRITICAL = 10000L;

    public TestForkJoinWork(Long start , Long end){
        this.start = start;
        this.end   = end;
    }

    @Override
    protected Long compute() {
        Long length = end - start;
        if (length <= CRITICAL){
            Long sum = 0L;
            for (Long i = start;i<=end;i++){
              sum += i;
            }
            return sum;
        }else{
            Long middle = (start+end) / 2;
            TestForkJoinWork right = new TestForkJoinWork(start,middle);
            right.fork(); // 拆分压入线程队列

            TestForkJoinWork left = new TestForkJoinWork(middle+1,end);
            left.fork(); // 拆分压入线程队列

            return right.join() + left.join();
        }
    }
}

class TestForkJoinWorkDemo{

     void test1(){
        //Fork/Join实现
        long l = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();//实现ForkJoin 就必须有ForkJoinPool的支持
        TestForkJoinWork task = new TestForkJoinWork(0L,10000000000L);//参数为起始值与结束值
        Long invoke = forkJoinPool.invoke(task);
        long l1 = System.currentTimeMillis();
        System.out.println("invoke = " + invoke+" time: " + (l1-l));
    }

    void test2(){
         // 普通线程完成
        Long x = 0L;
        Long y = 10000000000L;
        long l = System.currentTimeMillis();
        for (Long i = 0L; i <= y; i++) {
            x += i;
        }
        long l1 = System.currentTimeMillis();
        System.out.println("invoke = " + x+" time: " + (l1-l));
    }

    void test3(){
         // 并行流
        long l = System.currentTimeMillis();
        //parallel()与sequential()在并行流与串行流中随意切换
        long reduce = LongStream.rangeClosed(0, 10000000000L).parallel().reduce(0, Long::sum);
        long l1 = System.currentTimeMillis();
        System.out.println("invoke = " + reduce+" time: " + (l1-l));
    }

    public static void main(String[] args){
         TestForkJoinWorkDemo demo = new TestForkJoinWorkDemo();
         demo.test1();
         demo.test2();
         demo.test3();
        /**
         * invoke = -5340232216128654848 time: 40213
         * invoke = -5340232216128654848 time: 52510
       * invoke = -5340232216128654848 time: 963
         */
    }
}

分段锁（JUC）的原理、锁力度的减小思考

容器中有多把锁，每一把锁用于锁容器中的一部分数据。当多线程时访问容器中的不同数据段的数据时，线程间就不会发生锁竞争了。因而有效的提高了高并发的访问效率。例如ConcurrentHashMap使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也可被其他线程访问。ConcurrentHashMap中使用了一个包含16个锁的数组，每个锁保护所在的散列桶的1/16，其中第N个散列桶由第（N mod 16）个锁来保护。合理的使用散列算法来使关键字均匀分布，那么可使对锁的请求减少到原来的1/16。这样可使ConcurrentHashMap的并发达到16个线程。

独占锁：只有一把锁，每次只能一个线程能访问。例如HashTable。采用串行方式，会降低其伸缩性。一般有三种方式降低锁的竞争：

减少锁的持有时间
降低锁的请求频率
使用带有协调机制的独占锁，这些机制允许更高的并发性。

八种阻塞队列以及各个阻塞队列的特性

public class TestQueue {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        boolean flag;
        Object val;
        // 由数组结构组成的有界阻塞队列
        BlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(10);
        // 队未满时，返回true，队满时则抛出异常IllegalStateException
        flag = arrayBlockingQueue.add(obj);
        // 队未满时，返回true，队满时返回false。非阻塞立即返回
        arrayBlockingQueue.offer(obj);
        // 队未满时直接插入无返回值，队满时阻塞等待，一直等到队列未满时再插入
        arrayBlockingQueue.put(obj);

        // 队列不为空时，返回队首值并移除。队为空时抛出异常NoSuchElementException
        val = arrayBlockingQueue.remove();
        // 队列不为空时，返回队首值并移除。队为空时返回null。非阻塞立即返回
        val = arrayBlockingQueue.poll();
        // 设定等待的时间，如果在指定时间内队列为空则返回null，不为空则返回队首值
        val = arrayBlockingQueue.poll(1,TimeUnit.MINUTES);
        // 队列不为空返回队首值并移除；当队列为空时会阻塞等待，一直等到队列不为空时再返回队首值。
        val = arrayBlockingQueue.take();

        flag = arrayBlockingQueue.contains(obj);

        // 由链表结构组成的有界阻塞队列
        BlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(10);
        // 支持优先级别排序的无界阻塞队列默认大小为11
        BlockingQueue priorityBlockingQueue = new PriorityBlockingQueue();
        // 使用有限级队列实现的无界阻塞队列 PriorityQueue
        BlockingQueue delayQueue = new DelayQueue();
        // 不存储元素的阻塞队列
        BlockingQueue synchronousQueue = new SynchronousQueue();
        // 由链表结构组成的无界阻塞队列
        BlockingQueue linkedTransferQueue = new LinkedTransferQueue();
        // 由链表结构组成的双阻塞队列
        BlockingQueue linkedBlockingDeque = new LinkedBlockingDeque();
    }

Java基础-2、并发

synchronized

Volatile

信号量Semaphore

实现所有线程在等待某个事件的发生才去执行

CAS缺陷以及如何解决

AQS

死锁、活锁

线程池

线程池的种类

配置线程池大小

工作机制及原理

ThreadPoolExecutor类

ThreadLoad原理

LockSupport工具

Condition原理

Fork/Join框架的理解

分段锁（JUC）的原理、锁力度的减小思考

八种阻塞队列以及各个阻塞队列的特性

如何使用 JS 判断用户是否处于活跃状态

lightdb秒级增加列和删除列（not null带默认值）

lightdb数据库超时相关控制参数

通过HPA+CronHPA组合应对业务复杂弹性伸缩场景

❤️‍🔥 Solon Cloud Event 新的事务特性与应用

lightdb mysql 8.0兼容之不可见主键

使用 JS 实现在浏览器控制台打印图片 console.image()

基于Ubuntu-22.04安装K8s-v1.28.2实验（四）使用域名访问网站应用

Java集合優缺點總結

初識區塊鏈——比特幣

初識Redis

Spark機器學習

Java基礎-2、併發

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結